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


c1a213f47454c2ebaecb72cbd7d798f54cc8aa2e
[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_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafile swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseState swig_types[98]
2565 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2567 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxObject swig_types[104]
2571 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2578 #define SWIGTYPE_p_wxPoint swig_types[112]
2579 #define SWIGTYPE_p_wxPowerEvent swig_types[113]
2580 #define SWIGTYPE_p_wxProcessEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPyApp swig_types[115]
2582 #define SWIGTYPE_p_wxPyArtProvider swig_types[116]
2583 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[117]
2584 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[119]
2586 #define SWIGTYPE_p_wxPyDropSource swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
2588 #define SWIGTYPE_p_wxPyEvent swig_types[122]
2589 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyImageHandler swig_types[124]
2591 #define SWIGTYPE_p_wxPyLog swig_types[125]
2592 #define SWIGTYPE_p_wxPyProcess swig_types[126]
2593 #define SWIGTYPE_p_wxPySizer swig_types[127]
2594 #define SWIGTYPE_p_wxPyTextDataObject swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[129]
2596 #define SWIGTYPE_p_wxPyTimer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTipProvider swig_types[131]
2598 #define SWIGTYPE_p_wxPyValidator swig_types[132]
2599 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[133]
2600 #define SWIGTYPE_p_wxRect swig_types[134]
2601 #define SWIGTYPE_p_wxScrollEvent swig_types[135]
2602 #define SWIGTYPE_p_wxScrollWinEvent swig_types[136]
2603 #define SWIGTYPE_p_wxSetCursorEvent swig_types[137]
2604 #define SWIGTYPE_p_wxShowEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[139]
2606 #define SWIGTYPE_p_wxSize swig_types[140]
2607 #define SWIGTYPE_p_wxSizeEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSizer swig_types[142]
2609 #define SWIGTYPE_p_wxSizerItem swig_types[143]
2610 #define SWIGTYPE_p_wxSound swig_types[144]
2611 #define SWIGTYPE_p_wxStandardPaths swig_types[145]
2612 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[146]
2613 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStopWatch swig_types[148]
2615 #define SWIGTYPE_p_wxString swig_types[149]
2616 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[150]
2617 #define SWIGTYPE_p_wxSystemOptions swig_types[151]
2618 #define SWIGTYPE_p_wxSystemSettings swig_types[152]
2619 #define SWIGTYPE_p_wxTIFFHandler swig_types[153]
2620 #define SWIGTYPE_p_wxTextCtrl swig_types[154]
2621 #define SWIGTYPE_p_wxTextDataObject swig_types[155]
2622 #define SWIGTYPE_p_wxTimeSpan swig_types[156]
2623 #define SWIGTYPE_p_wxTimer swig_types[157]
2624 #define SWIGTYPE_p_wxTimerEvent swig_types[158]
2625 #define SWIGTYPE_p_wxTimerRunner swig_types[159]
2626 #define SWIGTYPE_p_wxTipProvider swig_types[160]
2627 #define SWIGTYPE_p_wxToolTip swig_types[161]
2628 #define SWIGTYPE_p_wxURLDataObject swig_types[162]
2629 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[163]
2630 #define SWIGTYPE_p_wxValidator swig_types[164]
2631 #define SWIGTYPE_p_wxVideoMode swig_types[165]
2632 #define SWIGTYPE_p_wxWindow swig_types[166]
2633 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[167]
2634 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDisabler swig_types[169]
2636 #define SWIGTYPE_p_wxXPMHandler swig_types[170]
2637 static swig_type_info *swig_types[172];
2638 static swig_module_info swig_module = {swig_types, 171, 0, 0, 0, 0};
2639 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2640 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2641
2642 /* -------- TYPES TABLE (END) -------- */
2643
2644 #if (PY_VERSION_HEX <= 0x02000000)
2645 # if !defined(SWIG_PYTHON_CLASSIC)
2646 # error "This python version requires to use swig with the '-classic' option"
2647 # endif
2648 #endif
2649 #if (PY_VERSION_HEX <= 0x02020000)
2650 # error "This python version requires to use swig with the '-nomodern' option"
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodernargs' option"
2654 #endif
2655 #ifndef METH_O
2656 # error "This python version requires to use swig with the '-nofastunpack' option"
2657 #endif
2658
2659 /*-----------------------------------------------
2660 @(target):= _misc_.so
2661 ------------------------------------------------*/
2662 #define SWIG_init init_misc_
2663
2664 #define SWIG_name "_misc_"
2665
2666 #define SWIGVERSION 0x010329
2667
2668
2669 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2670 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2671
2672
2673 #include <stdexcept>
2674
2675
2676 namespace swig {
2677 class PyObject_ptr {
2678 protected:
2679 PyObject *_obj;
2680
2681 public:
2682 PyObject_ptr() :_obj(0)
2683 {
2684 }
2685
2686 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2687 {
2688 Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2692 {
2693 if (initial_ref) Py_XINCREF(_obj);
2694 }
2695
2696 PyObject_ptr & operator=(const PyObject_ptr& item)
2697 {
2698 Py_XINCREF(item._obj);
2699 Py_XDECREF(_obj);
2700 _obj = item._obj;
2701 return *this;
2702 }
2703
2704 ~PyObject_ptr()
2705 {
2706 Py_XDECREF(_obj);
2707 }
2708
2709 operator PyObject *() const
2710 {
2711 return _obj;
2712 }
2713
2714 PyObject *operator->() const
2715 {
2716 return _obj;
2717 }
2718 };
2719 }
2720
2721
2722 namespace swig {
2723 struct PyObject_var : PyObject_ptr {
2724 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2725
2726 PyObject_var & operator = (PyObject* obj)
2727 {
2728 Py_XDECREF(_obj);
2729 _obj = obj;
2730 return *this;
2731 }
2732 };
2733 }
2734
2735
2736 #include "wx/wxPython/wxPython.h"
2737 #include "wx/wxPython/pyclasses.h"
2738 #include "wx/wxPython/pyistream.h"
2739
2740 static const wxString wxPyEmptyString(wxEmptyString);
2741
2742
2743
2744 #define SWIG_From_long PyInt_FromLong
2745
2746
2747 SWIGINTERNINLINE PyObject *
2748 SWIG_From_int (int value)
2749 {
2750 return SWIG_From_long (value);
2751 }
2752
2753
2754 #include <limits.h>
2755 #ifndef LLONG_MIN
2756 # define LLONG_MIN LONG_LONG_MIN
2757 #endif
2758 #ifndef LLONG_MAX
2759 # define LLONG_MAX LONG_LONG_MAX
2760 #endif
2761 #ifndef ULLONG_MAX
2762 # define ULLONG_MAX ULONG_LONG_MAX
2763 #endif
2764
2765
2766 SWIGINTERN int
2767 SWIG_AsVal_long (PyObject* obj, long* val)
2768 {
2769 if (PyNumber_Check(obj)) {
2770 if (val) *val = PyInt_AsLong(obj);
2771 return SWIG_OK;
2772 }
2773 return SWIG_TypeError;
2774 }
2775
2776
2777 SWIGINTERN int
2778 SWIG_AsVal_int (PyObject * obj, int *val)
2779 {
2780 long v;
2781 int res = SWIG_AsVal_long (obj, &v);
2782 if (SWIG_IsOK(res)) {
2783 if ((v < INT_MIN || v > INT_MAX)) {
2784 return SWIG_OverflowError;
2785 } else {
2786 if (val) *val = static_cast< int >(v);
2787 }
2788 }
2789 return res;
2790 }
2791
2792 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2793
2794 #include <wx/stockitem.h>
2795
2796 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2797 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2798 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2799
2800 SWIGINTERN int
2801 SWIG_AsVal_bool (PyObject *obj, bool *val)
2802 {
2803 if (obj == Py_True) {
2804 if (val) *val = true;
2805 return SWIG_OK;
2806 } else if (obj == Py_False) {
2807 if (val) *val = false;
2808 return SWIG_OK;
2809 } else {
2810 long v = 0;
2811 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2812 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2813 return res;
2814 }
2815 }
2816
2817
2818 SWIGINTERN int
2819 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2820 {
2821 long v = 0;
2822 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2823 return SWIG_TypeError;
2824 }
2825 else if (val)
2826 *val = (unsigned long)v;
2827 return SWIG_OK;
2828 }
2829
2830
2831 SWIGINTERNINLINE PyObject*
2832 SWIG_From_unsigned_SS_long (unsigned long value)
2833 {
2834 return (value > LONG_MAX) ?
2835 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2836 }
2837
2838
2839 void* wxGetXDisplay()
2840 {
2841 #ifdef __WXGTK__
2842 return wxGetDisplay();
2843 #else
2844 return NULL;
2845 #endif
2846 }
2847
2848
2849 wxWindow* FindWindowAtPointer() {
2850 wxPoint unused;
2851 return wxFindWindowAtPointer(unused);
2852 }
2853
2854
2855 bool wxThread_IsMain() {
2856 #ifdef WXP_WITH_THREAD
2857 return wxThread::IsMain();
2858 #else
2859 return true;
2860 #endif
2861 }
2862
2863 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2864 delete self;
2865 }
2866
2867 #include <wx/snglinst.h>
2868
2869
2870 #ifdef __WXMSW__
2871 #include <wx/msw/private.h>
2872 #include <wx/dynload.h>
2873 #endif
2874
2875
2876
2877 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2878 #if 0
2879 , int method
2880 #endif
2881 )
2882 {
2883 #ifdef __WXMSW__
2884 #if 0
2885 switch (method)
2886 {
2887 case 1:
2888 // This one only partially works. Appears to be an undocumented
2889 // "standard" convention that not all widgets adhear to. For
2890 // example, for some widgets backgrounds or non-client areas may
2891 // not be painted.
2892 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2893 break;
2894
2895 case 2:
2896 #endif
2897 // This one works much better, nearly all widgets and their
2898 // children are captured correctly[**]. Prior to the big
2899 // background erase changes that Vadim did in 2004-2005 this
2900 // method failed badly on XP with Themes activated, most native
2901 // widgets draw only partially, if at all. Without themes it
2902 // worked just like on Win2k. After those changes this method
2903 // works very well.
2904 //
2905 // ** For example the radio buttons in a wxRadioBox are not its
2906 // children by default, but you can capture it via the panel
2907 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2908 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2909 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2910 PRF_ERASEBKGND | PRF_OWNED );
2911 return true;
2912 #if 0
2913 break;
2914
2915 case 3:
2916 // This one is only defined in the latest SDK and is only
2917 // available on XP. MSDN says it is similar to sending WM_PRINT
2918 // so I expect that it will work similar to the above. Since it
2919 // is avaialble only on XP, it can't be compiled like this and
2920 // will have to be loaded dynamically.
2921 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2922
2923 // fall through
2924
2925 case 4:
2926 // Use PrintWindow if available, or fallback to WM_PRINT
2927 // otherwise. Unfortunately using PrintWindow is even worse than
2928 // WM_PRINT. For most native widgets nothing is drawn to the dc
2929 // at all, with or without Themes.
2930 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2931 static bool s_triedToLoad = false;
2932 static PrintWindow_t pfnPrintWindow = NULL;
2933 if ( !s_triedToLoad )
2934 {
2935
2936 s_triedToLoad = true;
2937 wxDynamicLibrary dllUser32(_T("user32.dll"));
2938 if ( dllUser32.IsLoaded() )
2939 {
2940 wxLogNull nolog; // Don't report errors here
2941 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2942 }
2943 }
2944 if (pfnPrintWindow)
2945 {
2946 //printf("Using PrintWindow\n");
2947 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2948 }
2949 else
2950 {
2951 //printf("Using WM_PRINT\n");
2952 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2953 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2954 PRF_ERASEBKGND | PRF_OWNED );
2955 }
2956 }
2957 #endif // 0
2958 #else
2959 return false;
2960 #endif // __WXMSW__
2961 }
2962
2963
2964
2965 #include <wx/tipdlg.h>
2966
2967
2968 SWIGINTERNINLINE PyObject *
2969 SWIG_From_size_t (size_t value)
2970 {
2971 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2972 }
2973
2974
2975 class wxPyTipProvider : public wxTipProvider {
2976 public:
2977 wxPyTipProvider(size_t currentTip)
2978 : wxTipProvider(currentTip) {}
2979
2980 DEC_PYCALLBACK_STRING__pure(GetTip);
2981 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2982 PYPRIVATE;
2983 };
2984
2985 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2986 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2987
2988
2989 SWIGINTERNINLINE int
2990 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2991 {
2992 unsigned long v;
2993 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2994 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2995 return res;
2996 }
2997
2998
2999 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3000
3001 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3002
3003 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3004 : wxTimer(owner, id)
3005 {
3006 if (owner == NULL)
3007 SetOwner(this);
3008 }
3009
3010
3011 SWIGINTERN swig_type_info*
3012 SWIG_pchar_descriptor()
3013 {
3014 static int init = 0;
3015 static swig_type_info* info = 0;
3016 if (!init) {
3017 info = SWIG_TypeQuery("_p_char");
3018 init = 1;
3019 }
3020 return info;
3021 }
3022
3023
3024 SWIGINTERNINLINE PyObject *
3025 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3026 {
3027 if (carray) {
3028 if (size > INT_MAX) {
3029 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3030 return pchar_descriptor ?
3031 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3032 } else {
3033 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3034 }
3035 } else {
3036 return SWIG_Py_Void();
3037 }
3038 }
3039
3040
3041 SWIGINTERNINLINE PyObject *
3042 SWIG_FromCharPtr(const char *cptr)
3043 {
3044 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3045 }
3046
3047
3048 SWIGINTERN int
3049 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3050 {
3051 unsigned long v;
3052 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3053 if (SWIG_IsOK(res)) {
3054 if ((v > UINT_MAX)) {
3055 return SWIG_OverflowError;
3056 } else {
3057 if (val) *val = static_cast< unsigned int >(v);
3058 }
3059 }
3060 return res;
3061 }
3062
3063 SWIGINTERN wxString wxLog_TimeStamp(){
3064 wxString msg;
3065 wxLog::TimeStamp(&msg);
3066 return msg;
3067 }
3068 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3069 // Make some wrappers that double any % signs so they are 'escaped'
3070 void wxPyLogFatalError(const wxString& msg)
3071 {
3072 wxString m(msg);
3073 m.Replace(wxT("%"), wxT("%%"));
3074 wxLogFatalError(m);
3075 }
3076
3077 void wxPyLogError(const wxString& msg)
3078 {
3079 wxString m(msg);
3080 m.Replace(wxT("%"), wxT("%%"));
3081 wxLogError(m);
3082 }
3083
3084 void wxPyLogWarning(const wxString& msg)
3085 {
3086 wxString m(msg);
3087 m.Replace(wxT("%"), wxT("%%"));
3088 wxLogWarning(m);
3089 }
3090
3091 void wxPyLogMessage(const wxString& msg)
3092 {
3093 wxString m(msg);
3094 m.Replace(wxT("%"), wxT("%%"));
3095 wxLogMessage(m);
3096 }
3097
3098 void wxPyLogInfo(const wxString& msg)
3099 {
3100 wxString m(msg);
3101 m.Replace(wxT("%"), wxT("%%"));
3102 wxLogInfo(m);
3103 }
3104
3105 void wxPyLogDebug(const wxString& msg)
3106 {
3107 wxString m(msg);
3108 m.Replace(wxT("%"), wxT("%%"));
3109 wxLogDebug(m);
3110 }
3111
3112 void wxPyLogVerbose(const wxString& msg)
3113 {
3114 wxString m(msg);
3115 m.Replace(wxT("%"), wxT("%%"));
3116 wxLogVerbose(m);
3117 }
3118
3119 void wxPyLogStatus(const wxString& msg)
3120 {
3121 wxString m(msg);
3122 m.Replace(wxT("%"), wxT("%%"));
3123 wxLogStatus(m);
3124 }
3125
3126 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3127 {
3128 wxString m(msg);
3129 m.Replace(wxT("%"), wxT("%%"));
3130 wxLogStatus(pFrame, m);
3131 }
3132
3133 void wxPyLogSysError(const wxString& msg)
3134 {
3135 wxString m(msg);
3136 m.Replace(wxT("%"), wxT("%%"));
3137 wxLogSysError(m);
3138 }
3139
3140 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3141 {
3142 wxString m(msg);
3143 m.Replace(wxT("%"), wxT("%%"));
3144 wxLogGeneric(level, m);
3145 }
3146
3147 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3148 {
3149 wxString m(msg);
3150 m.Replace(wxT("%"), wxT("%%"));
3151 wxLogTrace(mask, m);
3152 }
3153
3154 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3155 {
3156 wxString m(msg);
3157 m.Replace(wxT("%"), wxT("%%"));
3158 wxLogTrace(mask, m);
3159 }
3160
3161
3162
3163 // A wxLog class that can be derived from in wxPython
3164 class wxPyLog : public wxLog {
3165 public:
3166 wxPyLog() : wxLog() {}
3167
3168 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3169 bool found;
3170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3171 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3172 PyObject* s = wx2PyString(szString);
3173 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3174 Py_DECREF(s);
3175 }
3176 wxPyEndBlockThreads(blocked);
3177 if (! found)
3178 wxLog::DoLog(level, szString, t);
3179 }
3180
3181 virtual void DoLogString(const wxChar *szString, time_t t) {
3182 bool found;
3183 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3184 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3185 PyObject* s = wx2PyString(szString);
3186 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3187 Py_DECREF(s);
3188 }
3189 wxPyEndBlockThreads(blocked);
3190 if (! found)
3191 wxLog::DoLogString(szString, t);
3192 }
3193
3194 DEC_PYCALLBACK_VOID_(Flush);
3195 PYPRIVATE;
3196 };
3197 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3198
3199
3200
3201
3202 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3203
3204
3205 #include <wx/joystick.h>
3206
3207
3208 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3209 // A C++ stub class for wxJoystick for platforms that don't have it.
3210 class wxJoystick : public wxObject {
3211 public:
3212 wxJoystick(int joystick = wxJOYSTICK1) {
3213 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3214 PyErr_SetString(PyExc_NotImplementedError,
3215 "wxJoystick is not available on this platform.");
3216 wxPyEndBlockThreads(blocked);
3217 }
3218 wxPoint GetPosition() { return wxPoint(-1,-1); }
3219 int GetZPosition() { return -1; }
3220 int GetButtonState() { return -1; }
3221 int GetPOVPosition() { return -1; }
3222 int GetPOVCTSPosition() { return -1; }
3223 int GetRudderPosition() { return -1; }
3224 int GetUPosition() { return -1; }
3225 int GetVPosition() { return -1; }
3226 int GetMovementThreshold() { return -1; }
3227 void SetMovementThreshold(int threshold) {}
3228
3229 bool IsOk(void) { return false; }
3230 int GetNumberJoysticks() { return -1; }
3231 int GetManufacturerId() { return -1; }
3232 int GetProductId() { return -1; }
3233 wxString GetProductName() { return wxEmptyString; }
3234 int GetXMin() { return -1; }
3235 int GetYMin() { return -1; }
3236 int GetZMin() { return -1; }
3237 int GetXMax() { return -1; }
3238 int GetYMax() { return -1; }
3239 int GetZMax() { return -1; }
3240 int GetNumberButtons() { return -1; }
3241 int GetNumberAxes() { return -1; }
3242 int GetMaxButtons() { return -1; }
3243 int GetMaxAxes() { return -1; }
3244 int GetPollingMin() { return -1; }
3245 int GetPollingMax() { return -1; }
3246 int GetRudderMin() { return -1; }
3247 int GetRudderMax() { return -1; }
3248 int GetUMin() { return -1; }
3249 int GetUMax() { return -1; }
3250 int GetVMin() { return -1; }
3251 int GetVMax() { return -1; }
3252
3253 bool HasRudder() { return false; }
3254 bool HasZ() { return false; }
3255 bool HasU() { return false; }
3256 bool HasV() { return false; }
3257 bool HasPOV() { return false; }
3258 bool HasPOV4Dir() { return false; }
3259 bool HasPOVCTS() { return false; }
3260
3261 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3262 bool ReleaseCapture() { return false; }
3263 };
3264 #endif
3265
3266
3267 #include <wx/sound.h>
3268
3269
3270 #if !wxUSE_SOUND
3271 // A C++ stub class for wxWave for platforms that don't have it.
3272 class wxSound : public wxObject
3273 {
3274 public:
3275 wxSound() {
3276 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3277 PyErr_SetString(PyExc_NotImplementedError,
3278 "wxSound is not available on this platform.");
3279 wxPyEndBlockThreads(blocked);
3280 }
3281 wxSound(const wxString&/*, bool*/) {
3282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3283 PyErr_SetString(PyExc_NotImplementedError,
3284 "wxSound is not available on this platform.");
3285 wxPyEndBlockThreads(blocked);
3286 }
3287 wxSound(int, const wxByte*) {
3288 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3289 PyErr_SetString(PyExc_NotImplementedError,
3290 "wxSound is not available on this platform.");
3291 wxPyEndBlockThreads(blocked);
3292 }
3293
3294 ~wxSound() {};
3295
3296 bool Create(const wxString&/*, bool*/) { return false; }
3297 bool Create(int, const wxByte*) { return false; };
3298 bool IsOk() { return false; };
3299 bool Play(unsigned) const { return false; }
3300 static bool Play(const wxString&, unsigned) { return false; }
3301 static void Stop() {}
3302 };
3303
3304 #endif
3305
3306 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3307 if (fileName.Length() == 0)
3308 return new wxSound;
3309 else
3310 return new wxSound(fileName);
3311 }
3312 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3313 unsigned char* buffer; int size;
3314 wxSound *sound = NULL;
3315
3316 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3317 if (!PyArg_Parse(data, "t#", &buffer, &size))
3318 goto done;
3319 sound = new wxSound(size, buffer);
3320 done:
3321 wxPyEndBlockThreads(blocked);
3322 return sound;
3323 }
3324 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3325 #ifndef __WXMAC__
3326 unsigned char* buffer;
3327 int size;
3328 bool rv = false;
3329
3330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3331 if (!PyArg_Parse(data, "t#", &buffer, &size))
3332 goto done;
3333 rv = self->Create(size, buffer);
3334 done:
3335 wxPyEndBlockThreads(blocked);
3336 return rv;
3337 #else
3338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3339 PyErr_SetString(PyExc_NotImplementedError,
3340 "Create from data is not available on this platform.");
3341 wxPyEndBlockThreads(blocked);
3342 return false;
3343 #endif
3344 }
3345
3346 #include <wx/mimetype.h>
3347
3348 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3349 wxString str;
3350 if (self->GetMimeType(&str))
3351 return wx2PyString(str);
3352 else
3353 RETURN_NONE();
3354 }
3355 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3356 wxArrayString arr;
3357 if (self->GetMimeTypes(arr))
3358 return wxArrayString2PyList_helper(arr);
3359 else
3360 RETURN_NONE();
3361 }
3362 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3363 wxArrayString arr;
3364 if (self->GetExtensions(arr))
3365 return wxArrayString2PyList_helper(arr);
3366 else
3367 RETURN_NONE();
3368 }
3369 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3370 wxIconLocation loc;
3371 if (self->GetIcon(&loc))
3372 return new wxIcon(loc);
3373 else
3374 return NULL;
3375 }
3376 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3377 wxIconLocation loc;
3378 if (self->GetIcon(&loc)) {
3379 wxString iconFile = loc.GetFileName();
3380 int iconIndex = -1;
3381
3382 iconIndex = loc.GetIndex();
3383
3384 // Make a tuple and put the values in it
3385 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3386 PyObject* tuple = PyTuple_New(3);
3387 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3388 wxT("wxIcon"), true));
3389 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3390 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3391 wxPyEndBlockThreads(blocked);
3392 return tuple;
3393 }
3394 else
3395 RETURN_NONE();
3396 }
3397 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3398 wxString str;
3399 if (self->GetDescription(&str))
3400 return wx2PyString(str);
3401 else
3402 RETURN_NONE();
3403 }
3404 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3405 wxString str;
3406 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3407 return wx2PyString(str);
3408 else
3409 RETURN_NONE();
3410 }
3411 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3412 wxString str;
3413 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3414 return wx2PyString(str);
3415 else
3416 RETURN_NONE();
3417 }
3418 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3419 wxArrayString verbs;
3420 wxArrayString commands;
3421 if (self->GetAllCommands(&verbs, &commands,
3422 wxFileType::MessageParameters(filename, mimetype))) {
3423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3424 PyObject* tuple = PyTuple_New(2);
3425 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3426 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3427 wxPyEndBlockThreads(blocked);
3428 return tuple;
3429 }
3430 else
3431 RETURN_NONE();
3432 }
3433 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3434 return wxFileType::ExpandCommand(command,
3435 wxFileType::MessageParameters(filename, mimetype));
3436 }
3437 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3438 wxArrayString arr;
3439 self->EnumAllFileTypes(arr);
3440 return wxArrayString2PyList_helper(arr);
3441 }
3442
3443 #include <wx/artprov.h>
3444
3445 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3446 static const wxString wxPyART_MENU(wxART_MENU);
3447 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3448 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3449 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3450 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3451 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3452 static const wxString wxPyART_OTHER(wxART_OTHER);
3453 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3454 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3455 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3456 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3457 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3458 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3459 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3460 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3461 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3462 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3463 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3464 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3465 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3466 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3467 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3468 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3469 static const wxString wxPyART_PRINT(wxART_PRINT);
3470 static const wxString wxPyART_HELP(wxART_HELP);
3471 static const wxString wxPyART_TIP(wxART_TIP);
3472 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3473 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3474 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3475 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3476 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3477 static const wxString wxPyART_CDROM(wxART_CDROM);
3478 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3479 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3480 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3481 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3482 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3483 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3484 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3485 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3486 static const wxString wxPyART_ERROR(wxART_ERROR);
3487 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3488 static const wxString wxPyART_WARNING(wxART_WARNING);
3489 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3490 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3491 static const wxString wxPyART_COPY(wxART_COPY);
3492 static const wxString wxPyART_CUT(wxART_CUT);
3493 static const wxString wxPyART_PASTE(wxART_PASTE);
3494 static const wxString wxPyART_DELETE(wxART_DELETE);
3495 static const wxString wxPyART_NEW(wxART_NEW);
3496 static const wxString wxPyART_UNDO(wxART_UNDO);
3497 static const wxString wxPyART_REDO(wxART_REDO);
3498 static const wxString wxPyART_QUIT(wxART_QUIT);
3499 static const wxString wxPyART_FIND(wxART_FIND);
3500 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3501 // Python aware wxArtProvider
3502 class wxPyArtProvider : public wxArtProvider {
3503 public:
3504
3505 virtual wxBitmap CreateBitmap(const wxArtID& id,
3506 const wxArtClient& client,
3507 const wxSize& size) {
3508 wxBitmap rval = wxNullBitmap;
3509 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3510 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3511 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3512 PyObject* ro;
3513 wxBitmap* ptr;
3514 PyObject* s1, *s2;
3515 s1 = wx2PyString(id);
3516 s2 = wx2PyString(client);
3517 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3518 Py_DECREF(so);
3519 Py_DECREF(s1);
3520 Py_DECREF(s2);
3521 if (ro) {
3522 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3523 rval = *ptr;
3524 Py_DECREF(ro);
3525 }
3526 }
3527 wxPyEndBlockThreads(blocked);
3528 return rval;
3529 }
3530
3531 PYPRIVATE;
3532 };
3533
3534 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3535
3536
3537
3538 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3539 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3540 PyObject* ret = PyTuple_New(3);
3541 if (ret) {
3542 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3543 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3544 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3545 }
3546 wxPyEndBlockThreads(blocked);
3547 return ret;
3548 }
3549
3550 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3551 bool cont;
3552 long index = 0;
3553 wxString value;
3554
3555 cont = self->GetFirstGroup(value, index);
3556 return __EnumerationHelper(cont, value, index);
3557 }
3558 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3559 bool cont;
3560 wxString value;
3561
3562 cont = self->GetNextGroup(value, index);
3563 return __EnumerationHelper(cont, value, index);
3564 }
3565 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3566 bool cont;
3567 long index = 0;
3568 wxString value;
3569
3570 cont = self->GetFirstEntry(value, index);
3571 return __EnumerationHelper(cont, value, index);
3572 }
3573 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3574 bool cont;
3575 wxString value;
3576
3577 cont = self->GetNextEntry(value, index);
3578 return __EnumerationHelper(cont, value, index);
3579 }
3580 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3581 long rv;
3582 self->Read(key, &rv, defaultVal);
3583 return rv;
3584 }
3585
3586 SWIGINTERN int
3587 SWIG_AsVal_double (PyObject *obj, double* val)
3588 {
3589 if (PyNumber_Check(obj)) {
3590 if (val) *val = PyFloat_AsDouble(obj);
3591 return SWIG_OK;
3592 }
3593 return SWIG_TypeError;
3594 }
3595
3596 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3597 double rv;
3598 self->Read(key, &rv, defaultVal);
3599 return rv;
3600 }
3601
3602 #define SWIG_From_double PyFloat_FromDouble
3603
3604 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3605 bool rv;
3606 self->Read(key, &rv, defaultVal);
3607 return rv;
3608 }
3609
3610 #include <wx/datetime.h>
3611
3612 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3613 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3614
3615 #define LOCAL_TZ wxDateTime::Local
3616
3617 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3618 wxString am;
3619 wxString pm;
3620 wxDateTime::GetAmPmStrings(&am, &pm);
3621 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3622 PyObject* tup = PyTuple_New(2);
3623 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3624 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3625 wxPyEndBlockThreads(blocked);
3626 return tup;
3627 }
3628
3629 SWIGINTERNINLINE PyObject *
3630 SWIG_From_unsigned_SS_int (unsigned int value)
3631 {
3632 return SWIG_From_unsigned_SS_long (value);
3633 }
3634
3635 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3636 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3637 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3638 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3639 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3640 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3641 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3642 return (*self < *other);
3643 }
3644 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3645 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3646 return (*self <= *other);
3647 }
3648 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3649 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3650 return (*self > *other);
3651 }
3652 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3653 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3654 return (*self >= *other);
3655 }
3656 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3658 return (*self == *other);
3659 }
3660 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3662 return (*self != *other);
3663 }
3664 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3665 const wxChar* rv;
3666 const wxChar* _date = date;
3667 rv = self->ParseRfc822Date(_date);
3668 if (rv == NULL) return -1;
3669 return rv - _date;
3670 }
3671 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3672 const wxChar* rv;
3673 const wxChar* _date = date;
3674 rv = self->ParseFormat(_date, format, dateDef);
3675 if (rv == NULL) return -1;
3676 return rv - _date;
3677 }
3678 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3679 const wxChar* rv;
3680 const wxChar* _datetime = datetime;
3681 rv = self->ParseDateTime(_datetime);
3682 if (rv == NULL) return -1;
3683 return rv - _datetime;
3684 }
3685 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3686 const wxChar* rv;
3687 const wxChar* _date = date;
3688 rv = self->ParseDate(_date);
3689 if (rv == NULL) return -1;
3690 return rv - _date;
3691 }
3692 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3693 const wxChar* rv;
3694 const wxChar* _time = time;
3695 rv = self->ParseTime(_time);
3696 if (rv == NULL) return -1;
3697 return rv - _time;
3698 }
3699 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3700 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3703 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3704 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3705 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3706 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3707 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3709 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3710 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3711 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3712 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3713 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3714 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3715
3716 #include <wx/dataobj.h>
3717
3718 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3719 size_t count = self->GetFormatCount(dir);
3720 wxDataFormat* formats = new wxDataFormat[count];
3721 self->GetAllFormats(formats, dir);
3722
3723 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3724 PyObject* list = PyList_New(count);
3725 for (size_t i=0; i<count; i++) {
3726 wxDataFormat* format = new wxDataFormat(formats[i]);
3727 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3728 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3729 }
3730 wxPyEndBlockThreads(blocked);
3731 delete [] formats;
3732 return list;
3733 }
3734 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3735 PyObject* rval = NULL;
3736 size_t size = self->GetDataSize(format);
3737 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3738 if (size) {
3739 char* buf = new char[size];
3740 if (self->GetDataHere(format, buf))
3741 rval = PyString_FromStringAndSize(buf, size);
3742 delete [] buf;
3743 }
3744 if (! rval) {
3745 rval = Py_None;
3746 Py_INCREF(rval);
3747 }
3748 wxPyEndBlockThreads(blocked);
3749 return rval;
3750 }
3751 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3752 bool rval;
3753 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3754 if (PyString_Check(data)) {
3755 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3756 }
3757 else {
3758 // raise a TypeError if not a string
3759 PyErr_SetString(PyExc_TypeError, "String expected.");
3760 rval = false;
3761 }
3762 wxPyEndBlockThreads(blocked);
3763 return rval;
3764 }
3765 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3766 PyObject* rval = NULL;
3767 size_t size = self->GetDataSize();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 if (size) {
3770 char* buf = new char[size];
3771 if (self->GetDataHere(buf))
3772 rval = PyString_FromStringAndSize(buf, size);
3773 delete [] buf;
3774 }
3775 if (! rval) {
3776 rval = Py_None;
3777 Py_INCREF(rval);
3778 }
3779 wxPyEndBlockThreads(blocked);
3780 return rval;
3781 }
3782 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3783 bool rval;
3784 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3785 if (PyString_Check(data)) {
3786 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3787 }
3788 else {
3789 // raise a TypeError if not a string
3790 PyErr_SetString(PyExc_TypeError, "String expected.");
3791 rval = false;
3792 }
3793 wxPyEndBlockThreads(blocked);
3794 return rval;
3795 }
3796 // Create a new class for wxPython to use
3797 class wxPyDataObjectSimple : public wxDataObjectSimple {
3798 public:
3799 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3800 : wxDataObjectSimple(format) {}
3801
3802 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3803 bool GetDataHere(void *buf) const;
3804 bool SetData(size_t len, const void *buf);
3805 PYPRIVATE;
3806 };
3807
3808 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3809
3810 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3811 // We need to get the data for this object and write it to buf. I think
3812 // the best way to do this for wxPython is to have the Python method
3813 // return either a string or None and then act appropriately with the
3814 // C++ version.
3815
3816 bool rval = false;
3817 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3818 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3819 PyObject* ro;
3820 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3821 if (ro) {
3822 rval = (ro != Py_None && PyString_Check(ro));
3823 if (rval)
3824 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3825 Py_DECREF(ro);
3826 }
3827 }
3828 wxPyEndBlockThreads(blocked);
3829 return rval;
3830 }
3831
3832 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3833 // For this one we simply need to make a string from buf and len
3834 // and send it to the Python method.
3835 bool rval = false;
3836 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3837 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3838 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3839 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3840 Py_DECREF(data);
3841 }
3842 wxPyEndBlockThreads(blocked);
3843 return rval;
3844 }
3845
3846 // Create a new class for wxPython to use
3847 class wxPyTextDataObject : public wxTextDataObject {
3848 public:
3849 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3850 : wxTextDataObject(text) {}
3851
3852 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3853 DEC_PYCALLBACK_STRING__const(GetText);
3854 DEC_PYCALLBACK__STRING(SetText);
3855 PYPRIVATE;
3856 };
3857
3858 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3859 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3860 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3861
3862
3863 // Create a new class for wxPython to use
3864 class wxPyBitmapDataObject : public wxBitmapDataObject {
3865 public:
3866 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3867 : wxBitmapDataObject(bitmap) {}
3868
3869 wxBitmap GetBitmap() const;
3870 void SetBitmap(const wxBitmap& bitmap);
3871 PYPRIVATE;
3872 };
3873
3874 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3875 wxBitmap* rval = &wxNullBitmap;
3876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3877 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3878 PyObject* ro;
3879 wxBitmap* ptr;
3880 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3881 if (ro) {
3882 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3883 rval = ptr;
3884 Py_DECREF(ro);
3885 }
3886 }
3887 wxPyEndBlockThreads(blocked);
3888 return *rval;
3889 }
3890
3891 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3892 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3893 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3894 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3895 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3896 Py_DECREF(bo);
3897 }
3898 wxPyEndBlockThreads(blocked);
3899 }
3900
3901 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3902 return new wxCustomDataObject(wxDataFormat(formatName));
3903 }
3904 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3905 bool rval;
3906 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3907 if (PyString_Check(data)) {
3908 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3909 }
3910 else {
3911 // raise a TypeError if not a string
3912 PyErr_SetString(PyExc_TypeError, "String expected.");
3913 rval = false;
3914 }
3915 wxPyEndBlockThreads(blocked);
3916 return rval;
3917 }
3918 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3919 PyObject* obj;
3920 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3921 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3922 wxPyEndBlockThreads(blocked);
3923 return obj;
3924 }
3925
3926 #include <wx/metafile.h>
3927
3928
3929 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3930
3931
3932 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3933 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3934 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3935 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3936 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3937
3938
3939 class wxPyTextDropTarget : public wxTextDropTarget {
3940 public:
3941 wxPyTextDropTarget() {}
3942
3943 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3944
3945 DEC_PYCALLBACK__(OnLeave);
3946 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3947 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3949 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3950
3951 PYPRIVATE;
3952 };
3953
3954 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3955 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3956 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3957 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3959 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3960
3961
3962
3963 class wxPyFileDropTarget : public wxFileDropTarget {
3964 public:
3965 wxPyFileDropTarget() {}
3966
3967 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3968
3969 DEC_PYCALLBACK__(OnLeave);
3970 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3971 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3973 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3974
3975 PYPRIVATE;
3976 };
3977
3978 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3979 const wxArrayString& filenames) {
3980 bool rval = false;
3981 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3982 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3983 PyObject* list = wxArrayString2PyList_helper(filenames);
3984 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3985 Py_DECREF(list);
3986 }
3987 wxPyEndBlockThreads(blocked);
3988 return rval;
3989 }
3990
3991
3992
3993 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3994 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3995 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3997 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3998
3999
4000
4001
4002 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4003
4004 #include <wx/display.h>
4005
4006 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4007 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4008
4009 #if !wxUSE_DISPLAY
4010 const wxVideoMode wxDefaultVideoMode;
4011 #endif
4012
4013 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4014 #if wxUSE_DISPLAY
4015 PyObject* pyList = NULL;
4016 wxArrayVideoModes arr = self->GetModes(mode);
4017 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4018 pyList = PyList_New(0);
4019 for (size_t i=0; i < arr.GetCount(); i++)
4020 {
4021 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4022 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4023 PyList_Append(pyList, pyObj);
4024 Py_DECREF(pyObj);
4025 }
4026 wxPyEndBlockThreads(blocked);
4027 return pyList;
4028 #else
4029 wxPyRaiseNotImplemented();
4030 return NULL;
4031 #endif
4032 }
4033 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4034 #if wxUSE_DISPLAY
4035 return self->GetCurrentMode();
4036 #else
4037 wxPyRaiseNotImplemented();
4038 return wxDefaultVideoMode;
4039 #endif
4040 }
4041 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4042 #if wxUSE_DISPLAY
4043 return self->ChangeMode(mode);
4044 #else
4045 wxPyRaiseNotImplemented();
4046 return false;
4047 #endif
4048 }
4049 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4050 #if wxUSE_DISPLAY
4051 self->ResetMode();
4052 #else
4053 wxPyRaiseNotImplemented();
4054 #endif
4055 }
4056
4057 #include <wx/stdpaths.h>
4058
4059 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4060 return (wxStandardPaths*) &wxStandardPaths::Get();
4061 }
4062 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4063 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4064
4065 #ifndef wxHAS_POWER_EVENTS
4066 // Dummy class and other definitions for platforms that don't have them
4067
4068 // See wxPython_int.h for wxPowerEvent
4069
4070 enum {
4071 wxEVT_POWER_SUSPENDING,
4072 wxEVT_POWER_SUSPENDED,
4073 wxEVT_POWER_SUSPEND_CANCEL,
4074 wxEVT_POWER_RESUME,
4075 };
4076
4077 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4078 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4079
4080 #endif
4081
4082 #ifdef __cplusplus
4083 extern "C" {
4084 #endif
4085 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4086 PyObject *resultobj = 0;
4087 wxSystemColour arg1 ;
4088 wxColour result;
4089 int val1 ;
4090 int ecode1 = 0 ;
4091 PyObject * obj0 = 0 ;
4092 char * kwnames[] = {
4093 (char *) "index", NULL
4094 };
4095
4096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4097 ecode1 = SWIG_AsVal_int(obj0, &val1);
4098 if (!SWIG_IsOK(ecode1)) {
4099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4100 }
4101 arg1 = static_cast< wxSystemColour >(val1);
4102 {
4103 if (!wxPyCheckForApp()) SWIG_fail;
4104 PyThreadState* __tstate = wxPyBeginAllowThreads();
4105 result = wxSystemSettings::GetColour(arg1);
4106 wxPyEndAllowThreads(__tstate);
4107 if (PyErr_Occurred()) SWIG_fail;
4108 }
4109 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4110 return resultobj;
4111 fail:
4112 return NULL;
4113 }
4114
4115
4116 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4117 PyObject *resultobj = 0;
4118 wxSystemFont arg1 ;
4119 wxFont result;
4120 int val1 ;
4121 int ecode1 = 0 ;
4122 PyObject * obj0 = 0 ;
4123 char * kwnames[] = {
4124 (char *) "index", NULL
4125 };
4126
4127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4128 ecode1 = SWIG_AsVal_int(obj0, &val1);
4129 if (!SWIG_IsOK(ecode1)) {
4130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4131 }
4132 arg1 = static_cast< wxSystemFont >(val1);
4133 {
4134 if (!wxPyCheckForApp()) SWIG_fail;
4135 PyThreadState* __tstate = wxPyBeginAllowThreads();
4136 result = wxSystemSettings::GetFont(arg1);
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4141 return resultobj;
4142 fail:
4143 return NULL;
4144 }
4145
4146
4147 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4148 PyObject *resultobj = 0;
4149 wxSystemMetric arg1 ;
4150 wxWindow *arg2 = (wxWindow *) NULL ;
4151 int result;
4152 int val1 ;
4153 int ecode1 = 0 ;
4154 void *argp2 = 0 ;
4155 int res2 = 0 ;
4156 PyObject * obj0 = 0 ;
4157 PyObject * obj1 = 0 ;
4158 char * kwnames[] = {
4159 (char *) "index",(char *) "win", NULL
4160 };
4161
4162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4163 ecode1 = SWIG_AsVal_int(obj0, &val1);
4164 if (!SWIG_IsOK(ecode1)) {
4165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4166 }
4167 arg1 = static_cast< wxSystemMetric >(val1);
4168 if (obj1) {
4169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4170 if (!SWIG_IsOK(res2)) {
4171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4172 }
4173 arg2 = reinterpret_cast< wxWindow * >(argp2);
4174 }
4175 {
4176 if (!wxPyCheckForApp()) SWIG_fail;
4177 PyThreadState* __tstate = wxPyBeginAllowThreads();
4178 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4179 wxPyEndAllowThreads(__tstate);
4180 if (PyErr_Occurred()) SWIG_fail;
4181 }
4182 resultobj = SWIG_From_int(static_cast< int >(result));
4183 return resultobj;
4184 fail:
4185 return NULL;
4186 }
4187
4188
4189 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4190 PyObject *resultobj = 0;
4191 wxSystemFeature arg1 ;
4192 bool result;
4193 int val1 ;
4194 int ecode1 = 0 ;
4195 PyObject * obj0 = 0 ;
4196 char * kwnames[] = {
4197 (char *) "index", NULL
4198 };
4199
4200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4201 ecode1 = SWIG_AsVal_int(obj0, &val1);
4202 if (!SWIG_IsOK(ecode1)) {
4203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4204 }
4205 arg1 = static_cast< wxSystemFeature >(val1);
4206 {
4207 if (!wxPyCheckForApp()) SWIG_fail;
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (bool)wxSystemSettings::HasFeature(arg1);
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 {
4214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4215 }
4216 return resultobj;
4217 fail:
4218 return NULL;
4219 }
4220
4221
4222 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4223 PyObject *resultobj = 0;
4224 wxSystemScreenType result;
4225
4226 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4227 {
4228 if (!wxPyCheckForApp()) SWIG_fail;
4229 PyThreadState* __tstate = wxPyBeginAllowThreads();
4230 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4231 wxPyEndAllowThreads(__tstate);
4232 if (PyErr_Occurred()) SWIG_fail;
4233 }
4234 resultobj = SWIG_From_int(static_cast< int >(result));
4235 return resultobj;
4236 fail:
4237 return NULL;
4238 }
4239
4240
4241 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4242 PyObject *resultobj = 0;
4243 wxSystemScreenType arg1 ;
4244 int val1 ;
4245 int ecode1 = 0 ;
4246 PyObject * obj0 = 0 ;
4247 char * kwnames[] = {
4248 (char *) "screen", NULL
4249 };
4250
4251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4252 ecode1 = SWIG_AsVal_int(obj0, &val1);
4253 if (!SWIG_IsOK(ecode1)) {
4254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4255 }
4256 arg1 = static_cast< wxSystemScreenType >(val1);
4257 {
4258 if (!wxPyCheckForApp()) SWIG_fail;
4259 PyThreadState* __tstate = wxPyBeginAllowThreads();
4260 wxSystemSettings::SetScreenType(arg1);
4261 wxPyEndAllowThreads(__tstate);
4262 if (PyErr_Occurred()) SWIG_fail;
4263 }
4264 resultobj = SWIG_Py_Void();
4265 return resultobj;
4266 fail:
4267 return NULL;
4268 }
4269
4270
4271 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4272 PyObject *obj;
4273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4274 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4275 return SWIG_Py_Void();
4276 }
4277
4278 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4279 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4280 return 1;
4281 }
4282
4283
4284 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4285 PyObject *pyobj = 0;
4286
4287 {
4288 #if wxUSE_UNICODE
4289 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4290 #else
4291 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4292 #endif
4293 }
4294 return pyobj;
4295 }
4296
4297
4298 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4299 PyObject *resultobj = 0;
4300 wxSystemOptions *result = 0 ;
4301
4302 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 result = (wxSystemOptions *)new wxSystemOptions();
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4317 PyObject *resultobj = 0;
4318 wxString *arg1 = 0 ;
4319 wxString *arg2 = 0 ;
4320 bool temp1 = false ;
4321 bool temp2 = false ;
4322 PyObject * obj0 = 0 ;
4323 PyObject * obj1 = 0 ;
4324 char * kwnames[] = {
4325 (char *) "name",(char *) "value", NULL
4326 };
4327
4328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4329 {
4330 arg1 = wxString_in_helper(obj0);
4331 if (arg1 == NULL) SWIG_fail;
4332 temp1 = true;
4333 }
4334 {
4335 arg2 = wxString_in_helper(obj1);
4336 if (arg2 == NULL) SWIG_fail;
4337 temp2 = true;
4338 }
4339 {
4340 PyThreadState* __tstate = wxPyBeginAllowThreads();
4341 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4342 wxPyEndAllowThreads(__tstate);
4343 if (PyErr_Occurred()) SWIG_fail;
4344 }
4345 resultobj = SWIG_Py_Void();
4346 {
4347 if (temp1)
4348 delete arg1;
4349 }
4350 {
4351 if (temp2)
4352 delete arg2;
4353 }
4354 return resultobj;
4355 fail:
4356 {
4357 if (temp1)
4358 delete arg1;
4359 }
4360 {
4361 if (temp2)
4362 delete arg2;
4363 }
4364 return NULL;
4365 }
4366
4367
4368 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj = 0;
4370 wxString *arg1 = 0 ;
4371 int arg2 ;
4372 bool temp1 = false ;
4373 int val2 ;
4374 int ecode2 = 0 ;
4375 PyObject * obj0 = 0 ;
4376 PyObject * obj1 = 0 ;
4377 char * kwnames[] = {
4378 (char *) "name",(char *) "value", NULL
4379 };
4380
4381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4382 {
4383 arg1 = wxString_in_helper(obj0);
4384 if (arg1 == NULL) SWIG_fail;
4385 temp1 = true;
4386 }
4387 ecode2 = SWIG_AsVal_int(obj1, &val2);
4388 if (!SWIG_IsOK(ecode2)) {
4389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4390 }
4391 arg2 = static_cast< int >(val2);
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4395 wxPyEndAllowThreads(__tstate);
4396 if (PyErr_Occurred()) SWIG_fail;
4397 }
4398 resultobj = SWIG_Py_Void();
4399 {
4400 if (temp1)
4401 delete arg1;
4402 }
4403 return resultobj;
4404 fail:
4405 {
4406 if (temp1)
4407 delete arg1;
4408 }
4409 return NULL;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4414 PyObject *resultobj = 0;
4415 wxString *arg1 = 0 ;
4416 wxString result;
4417 bool temp1 = false ;
4418 PyObject * obj0 = 0 ;
4419 char * kwnames[] = {
4420 (char *) "name", NULL
4421 };
4422
4423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4424 {
4425 arg1 = wxString_in_helper(obj0);
4426 if (arg1 == NULL) SWIG_fail;
4427 temp1 = true;
4428 }
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 {
4436 #if wxUSE_UNICODE
4437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4438 #else
4439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4440 #endif
4441 }
4442 {
4443 if (temp1)
4444 delete arg1;
4445 }
4446 return resultobj;
4447 fail:
4448 {
4449 if (temp1)
4450 delete arg1;
4451 }
4452 return NULL;
4453 }
4454
4455
4456 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj = 0;
4458 wxString *arg1 = 0 ;
4459 int result;
4460 bool temp1 = false ;
4461 PyObject * obj0 = 0 ;
4462 char * kwnames[] = {
4463 (char *) "name", NULL
4464 };
4465
4466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4467 {
4468 arg1 = wxString_in_helper(obj0);
4469 if (arg1 == NULL) SWIG_fail;
4470 temp1 = true;
4471 }
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 resultobj = SWIG_From_int(static_cast< int >(result));
4479 {
4480 if (temp1)
4481 delete arg1;
4482 }
4483 return resultobj;
4484 fail:
4485 {
4486 if (temp1)
4487 delete arg1;
4488 }
4489 return NULL;
4490 }
4491
4492
4493 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4494 PyObject *resultobj = 0;
4495 wxString *arg1 = 0 ;
4496 bool result;
4497 bool temp1 = false ;
4498 PyObject * obj0 = 0 ;
4499 char * kwnames[] = {
4500 (char *) "name", NULL
4501 };
4502
4503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4504 {
4505 arg1 = wxString_in_helper(obj0);
4506 if (arg1 == NULL) SWIG_fail;
4507 temp1 = true;
4508 }
4509 {
4510 PyThreadState* __tstate = wxPyBeginAllowThreads();
4511 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4512 wxPyEndAllowThreads(__tstate);
4513 if (PyErr_Occurred()) SWIG_fail;
4514 }
4515 {
4516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4517 }
4518 {
4519 if (temp1)
4520 delete arg1;
4521 }
4522 return resultobj;
4523 fail:
4524 {
4525 if (temp1)
4526 delete arg1;
4527 }
4528 return NULL;
4529 }
4530
4531
4532 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4533 PyObject *resultobj = 0;
4534 wxString *arg1 = 0 ;
4535 bool result;
4536 bool temp1 = false ;
4537 PyObject * obj0 = 0 ;
4538 char * kwnames[] = {
4539 (char *) "name", NULL
4540 };
4541
4542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4543 {
4544 arg1 = wxString_in_helper(obj0);
4545 if (arg1 == NULL) SWIG_fail;
4546 temp1 = true;
4547 }
4548 {
4549 PyThreadState* __tstate = wxPyBeginAllowThreads();
4550 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4551 wxPyEndAllowThreads(__tstate);
4552 if (PyErr_Occurred()) SWIG_fail;
4553 }
4554 {
4555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4556 }
4557 {
4558 if (temp1)
4559 delete arg1;
4560 }
4561 return resultobj;
4562 fail:
4563 {
4564 if (temp1)
4565 delete arg1;
4566 }
4567 return NULL;
4568 }
4569
4570
4571 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4572 PyObject *obj;
4573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4574 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4575 return SWIG_Py_Void();
4576 }
4577
4578 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4579 return SWIG_Python_InitShadowInstance(args);
4580 }
4581
4582 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4583 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4584 return 1;
4585 }
4586
4587
4588 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4589 PyObject *pyobj = 0;
4590
4591 {
4592 #if wxUSE_UNICODE
4593 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4594 #else
4595 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4596 #endif
4597 }
4598 return pyobj;
4599 }
4600
4601
4602 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4603 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4604 return 1;
4605 }
4606
4607
4608 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4609 PyObject *pyobj = 0;
4610
4611 {
4612 #if wxUSE_UNICODE
4613 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4614 #else
4615 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4616 #endif
4617 }
4618 return pyobj;
4619 }
4620
4621
4622 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4623 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4624 return 1;
4625 }
4626
4627
4628 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4629 PyObject *pyobj = 0;
4630
4631 {
4632 #if wxUSE_UNICODE
4633 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4634 #else
4635 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4636 #endif
4637 }
4638 return pyobj;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4643 PyObject *resultobj = 0;
4644 long result;
4645
4646 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4647 {
4648 PyThreadState* __tstate = wxPyBeginAllowThreads();
4649 result = (long)wxNewId();
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 resultobj = SWIG_From_long(static_cast< long >(result));
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = 0;
4662 long arg1 ;
4663 long val1 ;
4664 int ecode1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "id", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4671 ecode1 = SWIG_AsVal_long(obj0, &val1);
4672 if (!SWIG_IsOK(ecode1)) {
4673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4674 }
4675 arg1 = static_cast< long >(val1);
4676 {
4677 PyThreadState* __tstate = wxPyBeginAllowThreads();
4678 wxRegisterId(arg1);
4679 wxPyEndAllowThreads(__tstate);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 resultobj = SWIG_Py_Void();
4683 return resultobj;
4684 fail:
4685 return NULL;
4686 }
4687
4688
4689 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4690 PyObject *resultobj = 0;
4691 long result;
4692
4693 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4694 {
4695 PyThreadState* __tstate = wxPyBeginAllowThreads();
4696 result = (long)wxGetCurrentId();
4697 wxPyEndAllowThreads(__tstate);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 resultobj = SWIG_From_long(static_cast< long >(result));
4701 return resultobj;
4702 fail:
4703 return NULL;
4704 }
4705
4706
4707 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4708 PyObject *resultobj = 0;
4709 int arg1 ;
4710 bool result;
4711 int val1 ;
4712 int ecode1 = 0 ;
4713 PyObject * obj0 = 0 ;
4714 char * kwnames[] = {
4715 (char *) "id", NULL
4716 };
4717
4718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4719 ecode1 = SWIG_AsVal_int(obj0, &val1);
4720 if (!SWIG_IsOK(ecode1)) {
4721 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4722 }
4723 arg1 = static_cast< int >(val1);
4724 {
4725 PyThreadState* __tstate = wxPyBeginAllowThreads();
4726 result = (bool)wxIsStockID(arg1);
4727 wxPyEndAllowThreads(__tstate);
4728 if (PyErr_Occurred()) SWIG_fail;
4729 }
4730 {
4731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4732 }
4733 return resultobj;
4734 fail:
4735 return NULL;
4736 }
4737
4738
4739 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4740 PyObject *resultobj = 0;
4741 int arg1 ;
4742 wxString *arg2 = 0 ;
4743 bool result;
4744 int val1 ;
4745 int ecode1 = 0 ;
4746 bool temp2 = false ;
4747 PyObject * obj0 = 0 ;
4748 PyObject * obj1 = 0 ;
4749 char * kwnames[] = {
4750 (char *) "id",(char *) "label", NULL
4751 };
4752
4753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4754 ecode1 = SWIG_AsVal_int(obj0, &val1);
4755 if (!SWIG_IsOK(ecode1)) {
4756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4757 }
4758 arg1 = static_cast< int >(val1);
4759 {
4760 arg2 = wxString_in_helper(obj1);
4761 if (arg2 == NULL) SWIG_fail;
4762 temp2 = true;
4763 }
4764 {
4765 PyThreadState* __tstate = wxPyBeginAllowThreads();
4766 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 {
4771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4772 }
4773 {
4774 if (temp2)
4775 delete arg2;
4776 }
4777 return resultobj;
4778 fail:
4779 {
4780 if (temp2)
4781 delete arg2;
4782 }
4783 return NULL;
4784 }
4785
4786
4787 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4788 PyObject *resultobj = 0;
4789 int arg1 ;
4790 bool arg2 = (bool) true ;
4791 wxString arg3 = (wxString) wxPyEmptyString ;
4792 wxString result;
4793 int val1 ;
4794 int ecode1 = 0 ;
4795 bool val2 ;
4796 int ecode2 = 0 ;
4797 PyObject * obj0 = 0 ;
4798 PyObject * obj1 = 0 ;
4799 PyObject * obj2 = 0 ;
4800 char * kwnames[] = {
4801 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4802 };
4803
4804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4805 ecode1 = SWIG_AsVal_int(obj0, &val1);
4806 if (!SWIG_IsOK(ecode1)) {
4807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4808 }
4809 arg1 = static_cast< int >(val1);
4810 if (obj1) {
4811 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4812 if (!SWIG_IsOK(ecode2)) {
4813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4814 }
4815 arg2 = static_cast< bool >(val2);
4816 }
4817 if (obj2) {
4818 {
4819 wxString* sptr = wxString_in_helper(obj2);
4820 if (sptr == NULL) SWIG_fail;
4821 arg3 = *sptr;
4822 delete sptr;
4823 }
4824 }
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 result = wxGetStockLabel(arg1,arg2,arg3);
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 {
4832 #if wxUSE_UNICODE
4833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4834 #else
4835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4836 #endif
4837 }
4838 return resultobj;
4839 fail:
4840 return NULL;
4841 }
4842
4843
4844 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4845 PyObject *resultobj = 0;
4846
4847 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4848 {
4849 if (!wxPyCheckForApp()) SWIG_fail;
4850 PyThreadState* __tstate = wxPyBeginAllowThreads();
4851 wxBell();
4852 wxPyEndAllowThreads(__tstate);
4853 if (PyErr_Occurred()) SWIG_fail;
4854 }
4855 resultobj = SWIG_Py_Void();
4856 return resultobj;
4857 fail:
4858 return NULL;
4859 }
4860
4861
4862 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4863 PyObject *resultobj = 0;
4864
4865 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4866 {
4867 if (!wxPyCheckForApp()) SWIG_fail;
4868 PyThreadState* __tstate = wxPyBeginAllowThreads();
4869 wxEndBusyCursor();
4870 wxPyEndAllowThreads(__tstate);
4871 if (PyErr_Occurred()) SWIG_fail;
4872 }
4873 resultobj = SWIG_Py_Void();
4874 return resultobj;
4875 fail:
4876 return NULL;
4877 }
4878
4879
4880 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4881 PyObject *resultobj = 0;
4882 bool arg1 = (bool) true ;
4883 long result;
4884 bool val1 ;
4885 int ecode1 = 0 ;
4886 PyObject * obj0 = 0 ;
4887 char * kwnames[] = {
4888 (char *) "resetTimer", NULL
4889 };
4890
4891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4892 if (obj0) {
4893 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4894 if (!SWIG_IsOK(ecode1)) {
4895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4896 }
4897 arg1 = static_cast< bool >(val1);
4898 }
4899 {
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 result = (long)wxGetElapsedTime(arg1);
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_From_long(static_cast< long >(result));
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4913 PyObject *resultobj = 0;
4914 bool result;
4915
4916 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4917 {
4918 PyThreadState* __tstate = wxPyBeginAllowThreads();
4919 result = (bool)wxIsBusy();
4920 wxPyEndAllowThreads(__tstate);
4921 if (PyErr_Occurred()) SWIG_fail;
4922 }
4923 {
4924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4925 }
4926 return resultobj;
4927 fail:
4928 return NULL;
4929 }
4930
4931
4932 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4933 PyObject *resultobj = 0;
4934 wxString result;
4935
4936 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4937 {
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 result = wxNow();
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 {
4944 #if wxUSE_UNICODE
4945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4946 #else
4947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4948 #endif
4949 }
4950 return resultobj;
4951 fail:
4952 return NULL;
4953 }
4954
4955
4956 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4957 PyObject *resultobj = 0;
4958 wxString const &arg1_defvalue = wxPyEmptyString ;
4959 wxString *arg1 = (wxString *) &arg1_defvalue ;
4960 bool result;
4961 bool temp1 = false ;
4962 PyObject * obj0 = 0 ;
4963 char * kwnames[] = {
4964 (char *) "command", NULL
4965 };
4966
4967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4968 if (obj0) {
4969 {
4970 arg1 = wxString_in_helper(obj0);
4971 if (arg1 == NULL) SWIG_fail;
4972 temp1 = true;
4973 }
4974 }
4975 {
4976 PyThreadState* __tstate = wxPyBeginAllowThreads();
4977 result = (bool)wxShell((wxString const &)*arg1);
4978 wxPyEndAllowThreads(__tstate);
4979 if (PyErr_Occurred()) SWIG_fail;
4980 }
4981 {
4982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4983 }
4984 {
4985 if (temp1)
4986 delete arg1;
4987 }
4988 return resultobj;
4989 fail:
4990 {
4991 if (temp1)
4992 delete arg1;
4993 }
4994 return NULL;
4995 }
4996
4997
4998 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4999 PyObject *resultobj = 0;
5000
5001 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5002 {
5003 PyThreadState* __tstate = wxPyBeginAllowThreads();
5004 wxStartTimer();
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 resultobj = SWIG_Py_Void();
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5016 PyObject *resultobj = 0;
5017 int *arg1 = (int *) 0 ;
5018 int *arg2 = (int *) 0 ;
5019 int result;
5020 int temp1 ;
5021 int res1 = SWIG_TMPOBJ ;
5022 int temp2 ;
5023 int res2 = SWIG_TMPOBJ ;
5024
5025 arg1 = &temp1;
5026 arg2 = &temp2;
5027 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5028 {
5029 PyThreadState* __tstate = wxPyBeginAllowThreads();
5030 result = (int)wxGetOsVersion(arg1,arg2);
5031 wxPyEndAllowThreads(__tstate);
5032 if (PyErr_Occurred()) SWIG_fail;
5033 }
5034 resultobj = SWIG_From_int(static_cast< int >(result));
5035 if (SWIG_IsTmpObj(res1)) {
5036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5037 } else {
5038 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5040 }
5041 if (SWIG_IsTmpObj(res2)) {
5042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5043 } else {
5044 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5046 }
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5054 PyObject *resultobj = 0;
5055 wxString result;
5056
5057 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5058 {
5059 PyThreadState* __tstate = wxPyBeginAllowThreads();
5060 result = wxGetOsDescription();
5061 wxPyEndAllowThreads(__tstate);
5062 if (PyErr_Occurred()) SWIG_fail;
5063 }
5064 {
5065 #if wxUSE_UNICODE
5066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5067 #else
5068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5069 #endif
5070 }
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5078 PyObject *resultobj = 0;
5079 wxMemorySize result;
5080
5081 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 result = wxGetFreeMemory();
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 {
5089 #if wxUSE_LONGLONG
5090 resultobj = PyLong_FromLongLong((&result)->GetValue());
5091 #else
5092 resultobj = PyInt_FromLong(result);
5093 #endif
5094 }
5095 return resultobj;
5096 fail:
5097 return NULL;
5098 }
5099
5100
5101 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5102 PyObject *resultobj = 0;
5103 wxShutdownFlags arg1 ;
5104 bool result;
5105 int val1 ;
5106 int ecode1 = 0 ;
5107 PyObject * obj0 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "wFlags", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5113 ecode1 = SWIG_AsVal_int(obj0, &val1);
5114 if (!SWIG_IsOK(ecode1)) {
5115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5116 }
5117 arg1 = static_cast< wxShutdownFlags >(val1);
5118 {
5119 if (!wxPyCheckForApp()) SWIG_fail;
5120 PyThreadState* __tstate = wxPyBeginAllowThreads();
5121 result = (bool)wxShutdown(arg1);
5122 wxPyEndAllowThreads(__tstate);
5123 if (PyErr_Occurred()) SWIG_fail;
5124 }
5125 {
5126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5127 }
5128 return resultobj;
5129 fail:
5130 return NULL;
5131 }
5132
5133
5134 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5135 PyObject *resultobj = 0;
5136 int arg1 ;
5137 int val1 ;
5138 int ecode1 = 0 ;
5139 PyObject * obj0 = 0 ;
5140 char * kwnames[] = {
5141 (char *) "secs", NULL
5142 };
5143
5144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5145 ecode1 = SWIG_AsVal_int(obj0, &val1);
5146 if (!SWIG_IsOK(ecode1)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5148 }
5149 arg1 = static_cast< int >(val1);
5150 {
5151 PyThreadState* __tstate = wxPyBeginAllowThreads();
5152 wxSleep(arg1);
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 resultobj = SWIG_Py_Void();
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5164 PyObject *resultobj = 0;
5165 unsigned long arg1 ;
5166 unsigned long val1 ;
5167 int ecode1 = 0 ;
5168 PyObject * obj0 = 0 ;
5169 char * kwnames[] = {
5170 (char *) "milliseconds", NULL
5171 };
5172
5173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5174 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5175 if (!SWIG_IsOK(ecode1)) {
5176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5177 }
5178 arg1 = static_cast< unsigned long >(val1);
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 wxMilliSleep(arg1);
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 resultobj = SWIG_Py_Void();
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj = 0;
5194 unsigned long arg1 ;
5195 unsigned long val1 ;
5196 int ecode1 = 0 ;
5197 PyObject * obj0 = 0 ;
5198 char * kwnames[] = {
5199 (char *) "microseconds", NULL
5200 };
5201
5202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5203 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5204 if (!SWIG_IsOK(ecode1)) {
5205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5206 }
5207 arg1 = static_cast< unsigned long >(val1);
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 wxMicroSleep(arg1);
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 resultobj = SWIG_Py_Void();
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj = 0;
5223 bool arg1 ;
5224 bool val1 ;
5225 int ecode1 = 0 ;
5226 PyObject * obj0 = 0 ;
5227 char * kwnames[] = {
5228 (char *) "enable", NULL
5229 };
5230
5231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5232 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5233 if (!SWIG_IsOK(ecode1)) {
5234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5235 }
5236 arg1 = static_cast< bool >(val1);
5237 {
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 wxEnableTopLevelWindows(arg1);
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_Py_Void();
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj = 0;
5252 wxString *arg1 = 0 ;
5253 wxString result;
5254 bool temp1 = false ;
5255 PyObject * obj0 = 0 ;
5256 char * kwnames[] = {
5257 (char *) "in", NULL
5258 };
5259
5260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5261 {
5262 arg1 = wxString_in_helper(obj0);
5263 if (arg1 == NULL) SWIG_fail;
5264 temp1 = true;
5265 }
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = wxStripMenuCodes((wxString const &)*arg1);
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 {
5273 #if wxUSE_UNICODE
5274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5275 #else
5276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5277 #endif
5278 }
5279 {
5280 if (temp1)
5281 delete arg1;
5282 }
5283 return resultobj;
5284 fail:
5285 {
5286 if (temp1)
5287 delete arg1;
5288 }
5289 return NULL;
5290 }
5291
5292
5293 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5294 PyObject *resultobj = 0;
5295 wxString result;
5296
5297 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5298 {
5299 PyThreadState* __tstate = wxPyBeginAllowThreads();
5300 result = wxGetEmailAddress();
5301 wxPyEndAllowThreads(__tstate);
5302 if (PyErr_Occurred()) SWIG_fail;
5303 }
5304 {
5305 #if wxUSE_UNICODE
5306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5307 #else
5308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5309 #endif
5310 }
5311 return resultobj;
5312 fail:
5313 return NULL;
5314 }
5315
5316
5317 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5318 PyObject *resultobj = 0;
5319 wxString result;
5320
5321 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = wxGetHostName();
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 {
5329 #if wxUSE_UNICODE
5330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5331 #else
5332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5333 #endif
5334 }
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5342 PyObject *resultobj = 0;
5343 wxString result;
5344
5345 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5346 {
5347 PyThreadState* __tstate = wxPyBeginAllowThreads();
5348 result = wxGetFullHostName();
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 {
5353 #if wxUSE_UNICODE
5354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5355 #else
5356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5357 #endif
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5366 PyObject *resultobj = 0;
5367 wxString result;
5368
5369 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5370 {
5371 PyThreadState* __tstate = wxPyBeginAllowThreads();
5372 result = wxGetUserId();
5373 wxPyEndAllowThreads(__tstate);
5374 if (PyErr_Occurred()) SWIG_fail;
5375 }
5376 {
5377 #if wxUSE_UNICODE
5378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5379 #else
5380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5381 #endif
5382 }
5383 return resultobj;
5384 fail:
5385 return NULL;
5386 }
5387
5388
5389 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5390 PyObject *resultobj = 0;
5391 wxString result;
5392
5393 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5394 {
5395 PyThreadState* __tstate = wxPyBeginAllowThreads();
5396 result = wxGetUserName();
5397 wxPyEndAllowThreads(__tstate);
5398 if (PyErr_Occurred()) SWIG_fail;
5399 }
5400 {
5401 #if wxUSE_UNICODE
5402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5403 #else
5404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5405 #endif
5406 }
5407 return resultobj;
5408 fail:
5409 return NULL;
5410 }
5411
5412
5413 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5414 PyObject *resultobj = 0;
5415 wxString result;
5416
5417 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5418 {
5419 PyThreadState* __tstate = wxPyBeginAllowThreads();
5420 result = wxGetHomeDir();
5421 wxPyEndAllowThreads(__tstate);
5422 if (PyErr_Occurred()) SWIG_fail;
5423 }
5424 {
5425 #if wxUSE_UNICODE
5426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5427 #else
5428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5429 #endif
5430 }
5431 return resultobj;
5432 fail:
5433 return NULL;
5434 }
5435
5436
5437 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5438 PyObject *resultobj = 0;
5439 wxString const &arg1_defvalue = wxPyEmptyString ;
5440 wxString *arg1 = (wxString *) &arg1_defvalue ;
5441 wxString result;
5442 bool temp1 = false ;
5443 PyObject * obj0 = 0 ;
5444 char * kwnames[] = {
5445 (char *) "user", NULL
5446 };
5447
5448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5449 if (obj0) {
5450 {
5451 arg1 = wxString_in_helper(obj0);
5452 if (arg1 == NULL) SWIG_fail;
5453 temp1 = true;
5454 }
5455 }
5456 {
5457 PyThreadState* __tstate = wxPyBeginAllowThreads();
5458 result = wxGetUserHome((wxString const &)*arg1);
5459 wxPyEndAllowThreads(__tstate);
5460 if (PyErr_Occurred()) SWIG_fail;
5461 }
5462 {
5463 #if wxUSE_UNICODE
5464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5465 #else
5466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5467 #endif
5468 }
5469 {
5470 if (temp1)
5471 delete arg1;
5472 }
5473 return resultobj;
5474 fail:
5475 {
5476 if (temp1)
5477 delete arg1;
5478 }
5479 return NULL;
5480 }
5481
5482
5483 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5484 PyObject *resultobj = 0;
5485 unsigned long result;
5486
5487 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5488 {
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (unsigned long)wxGetProcessId();
5491 wxPyEndAllowThreads(__tstate);
5492 if (PyErr_Occurred()) SWIG_fail;
5493 }
5494 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5495 return resultobj;
5496 fail:
5497 return NULL;
5498 }
5499
5500
5501 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5502 PyObject *resultobj = 0;
5503
5504 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 wxTrap();
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_Py_Void();
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5521 wxString *arg1 = (wxString *) &arg1_defvalue ;
5522 wxString const &arg2_defvalue = wxPyEmptyString ;
5523 wxString *arg2 = (wxString *) &arg2_defvalue ;
5524 wxString const &arg3_defvalue = wxPyEmptyString ;
5525 wxString *arg3 = (wxString *) &arg3_defvalue ;
5526 wxString const &arg4_defvalue = wxPyEmptyString ;
5527 wxString *arg4 = (wxString *) &arg4_defvalue ;
5528 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5529 wxString *arg5 = (wxString *) &arg5_defvalue ;
5530 int arg6 = (int) 0 ;
5531 wxWindow *arg7 = (wxWindow *) NULL ;
5532 int arg8 = (int) -1 ;
5533 int arg9 = (int) -1 ;
5534 wxString result;
5535 bool temp1 = false ;
5536 bool temp2 = false ;
5537 bool temp3 = false ;
5538 bool temp4 = false ;
5539 bool temp5 = false ;
5540 int val6 ;
5541 int ecode6 = 0 ;
5542 void *argp7 = 0 ;
5543 int res7 = 0 ;
5544 int val8 ;
5545 int ecode8 = 0 ;
5546 int val9 ;
5547 int ecode9 = 0 ;
5548 PyObject * obj0 = 0 ;
5549 PyObject * obj1 = 0 ;
5550 PyObject * obj2 = 0 ;
5551 PyObject * obj3 = 0 ;
5552 PyObject * obj4 = 0 ;
5553 PyObject * obj5 = 0 ;
5554 PyObject * obj6 = 0 ;
5555 PyObject * obj7 = 0 ;
5556 PyObject * obj8 = 0 ;
5557 char * kwnames[] = {
5558 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5559 };
5560
5561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5562 if (obj0) {
5563 {
5564 arg1 = wxString_in_helper(obj0);
5565 if (arg1 == NULL) SWIG_fail;
5566 temp1 = true;
5567 }
5568 }
5569 if (obj1) {
5570 {
5571 arg2 = wxString_in_helper(obj1);
5572 if (arg2 == NULL) SWIG_fail;
5573 temp2 = true;
5574 }
5575 }
5576 if (obj2) {
5577 {
5578 arg3 = wxString_in_helper(obj2);
5579 if (arg3 == NULL) SWIG_fail;
5580 temp3 = true;
5581 }
5582 }
5583 if (obj3) {
5584 {
5585 arg4 = wxString_in_helper(obj3);
5586 if (arg4 == NULL) SWIG_fail;
5587 temp4 = true;
5588 }
5589 }
5590 if (obj4) {
5591 {
5592 arg5 = wxString_in_helper(obj4);
5593 if (arg5 == NULL) SWIG_fail;
5594 temp5 = true;
5595 }
5596 }
5597 if (obj5) {
5598 ecode6 = SWIG_AsVal_int(obj5, &val6);
5599 if (!SWIG_IsOK(ecode6)) {
5600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5601 }
5602 arg6 = static_cast< int >(val6);
5603 }
5604 if (obj6) {
5605 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5606 if (!SWIG_IsOK(res7)) {
5607 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5608 }
5609 arg7 = reinterpret_cast< wxWindow * >(argp7);
5610 }
5611 if (obj7) {
5612 ecode8 = SWIG_AsVal_int(obj7, &val8);
5613 if (!SWIG_IsOK(ecode8)) {
5614 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5615 }
5616 arg8 = static_cast< int >(val8);
5617 }
5618 if (obj8) {
5619 ecode9 = SWIG_AsVal_int(obj8, &val9);
5620 if (!SWIG_IsOK(ecode9)) {
5621 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5622 }
5623 arg9 = static_cast< int >(val9);
5624 }
5625 {
5626 if (!wxPyCheckForApp()) SWIG_fail;
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 {
5633 #if wxUSE_UNICODE
5634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5635 #else
5636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5637 #endif
5638 }
5639 {
5640 if (temp1)
5641 delete arg1;
5642 }
5643 {
5644 if (temp2)
5645 delete arg2;
5646 }
5647 {
5648 if (temp3)
5649 delete arg3;
5650 }
5651 {
5652 if (temp4)
5653 delete arg4;
5654 }
5655 {
5656 if (temp5)
5657 delete arg5;
5658 }
5659 return resultobj;
5660 fail:
5661 {
5662 if (temp1)
5663 delete arg1;
5664 }
5665 {
5666 if (temp2)
5667 delete arg2;
5668 }
5669 {
5670 if (temp3)
5671 delete arg3;
5672 }
5673 {
5674 if (temp4)
5675 delete arg4;
5676 }
5677 {
5678 if (temp5)
5679 delete arg5;
5680 }
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj = 0;
5687 wxString *arg1 = 0 ;
5688 wxString *arg2 = 0 ;
5689 wxString const &arg3_defvalue = wxPyEmptyString ;
5690 wxString *arg3 = (wxString *) &arg3_defvalue ;
5691 wxWindow *arg4 = (wxWindow *) NULL ;
5692 wxString result;
5693 bool temp1 = false ;
5694 bool temp2 = false ;
5695 bool temp3 = false ;
5696 void *argp4 = 0 ;
5697 int res4 = 0 ;
5698 PyObject * obj0 = 0 ;
5699 PyObject * obj1 = 0 ;
5700 PyObject * obj2 = 0 ;
5701 PyObject * obj3 = 0 ;
5702 char * kwnames[] = {
5703 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5704 };
5705
5706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5707 {
5708 arg1 = wxString_in_helper(obj0);
5709 if (arg1 == NULL) SWIG_fail;
5710 temp1 = true;
5711 }
5712 {
5713 arg2 = wxString_in_helper(obj1);
5714 if (arg2 == NULL) SWIG_fail;
5715 temp2 = true;
5716 }
5717 if (obj2) {
5718 {
5719 arg3 = wxString_in_helper(obj2);
5720 if (arg3 == NULL) SWIG_fail;
5721 temp3 = true;
5722 }
5723 }
5724 if (obj3) {
5725 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5726 if (!SWIG_IsOK(res4)) {
5727 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5728 }
5729 arg4 = reinterpret_cast< wxWindow * >(argp4);
5730 }
5731 {
5732 if (!wxPyCheckForApp()) SWIG_fail;
5733 PyThreadState* __tstate = wxPyBeginAllowThreads();
5734 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5735 wxPyEndAllowThreads(__tstate);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 {
5739 #if wxUSE_UNICODE
5740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5741 #else
5742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5743 #endif
5744 }
5745 {
5746 if (temp1)
5747 delete arg1;
5748 }
5749 {
5750 if (temp2)
5751 delete arg2;
5752 }
5753 {
5754 if (temp3)
5755 delete arg3;
5756 }
5757 return resultobj;
5758 fail:
5759 {
5760 if (temp1)
5761 delete arg1;
5762 }
5763 {
5764 if (temp2)
5765 delete arg2;
5766 }
5767 {
5768 if (temp3)
5769 delete arg3;
5770 }
5771 return NULL;
5772 }
5773
5774
5775 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5776 PyObject *resultobj = 0;
5777 wxString *arg1 = 0 ;
5778 wxString *arg2 = 0 ;
5779 wxString const &arg3_defvalue = wxPyEmptyString ;
5780 wxString *arg3 = (wxString *) &arg3_defvalue ;
5781 wxWindow *arg4 = (wxWindow *) NULL ;
5782 wxString result;
5783 bool temp1 = false ;
5784 bool temp2 = false ;
5785 bool temp3 = false ;
5786 void *argp4 = 0 ;
5787 int res4 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 PyObject * obj2 = 0 ;
5791 PyObject * obj3 = 0 ;
5792 char * kwnames[] = {
5793 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5794 };
5795
5796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5797 {
5798 arg1 = wxString_in_helper(obj0);
5799 if (arg1 == NULL) SWIG_fail;
5800 temp1 = true;
5801 }
5802 {
5803 arg2 = wxString_in_helper(obj1);
5804 if (arg2 == NULL) SWIG_fail;
5805 temp2 = true;
5806 }
5807 if (obj2) {
5808 {
5809 arg3 = wxString_in_helper(obj2);
5810 if (arg3 == NULL) SWIG_fail;
5811 temp3 = true;
5812 }
5813 }
5814 if (obj3) {
5815 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5816 if (!SWIG_IsOK(res4)) {
5817 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5818 }
5819 arg4 = reinterpret_cast< wxWindow * >(argp4);
5820 }
5821 {
5822 if (!wxPyCheckForApp()) SWIG_fail;
5823 PyThreadState* __tstate = wxPyBeginAllowThreads();
5824 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5825 wxPyEndAllowThreads(__tstate);
5826 if (PyErr_Occurred()) SWIG_fail;
5827 }
5828 {
5829 #if wxUSE_UNICODE
5830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5831 #else
5832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5833 #endif
5834 }
5835 {
5836 if (temp1)
5837 delete arg1;
5838 }
5839 {
5840 if (temp2)
5841 delete arg2;
5842 }
5843 {
5844 if (temp3)
5845 delete arg3;
5846 }
5847 return resultobj;
5848 fail:
5849 {
5850 if (temp1)
5851 delete arg1;
5852 }
5853 {
5854 if (temp2)
5855 delete arg2;
5856 }
5857 {
5858 if (temp3)
5859 delete arg3;
5860 }
5861 return NULL;
5862 }
5863
5864
5865 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj = 0;
5867 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5868 wxString *arg1 = (wxString *) &arg1_defvalue ;
5869 wxString const &arg2_defvalue = wxPyEmptyString ;
5870 wxString *arg2 = (wxString *) &arg2_defvalue ;
5871 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5872 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5873 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5874 wxWindow *arg5 = (wxWindow *) NULL ;
5875 wxString result;
5876 bool temp1 = false ;
5877 bool temp2 = false ;
5878 long val3 ;
5879 int ecode3 = 0 ;
5880 wxPoint temp4 ;
5881 void *argp5 = 0 ;
5882 int res5 = 0 ;
5883 PyObject * obj0 = 0 ;
5884 PyObject * obj1 = 0 ;
5885 PyObject * obj2 = 0 ;
5886 PyObject * obj3 = 0 ;
5887 PyObject * obj4 = 0 ;
5888 char * kwnames[] = {
5889 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5890 };
5891
5892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5893 if (obj0) {
5894 {
5895 arg1 = wxString_in_helper(obj0);
5896 if (arg1 == NULL) SWIG_fail;
5897 temp1 = true;
5898 }
5899 }
5900 if (obj1) {
5901 {
5902 arg2 = wxString_in_helper(obj1);
5903 if (arg2 == NULL) SWIG_fail;
5904 temp2 = true;
5905 }
5906 }
5907 if (obj2) {
5908 ecode3 = SWIG_AsVal_long(obj2, &val3);
5909 if (!SWIG_IsOK(ecode3)) {
5910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5911 }
5912 arg3 = static_cast< long >(val3);
5913 }
5914 if (obj3) {
5915 {
5916 arg4 = &temp4;
5917 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5918 }
5919 }
5920 if (obj4) {
5921 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5922 if (!SWIG_IsOK(res5)) {
5923 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5924 }
5925 arg5 = reinterpret_cast< wxWindow * >(argp5);
5926 }
5927 {
5928 if (!wxPyCheckForApp()) SWIG_fail;
5929 PyThreadState* __tstate = wxPyBeginAllowThreads();
5930 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 {
5935 #if wxUSE_UNICODE
5936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5937 #else
5938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5939 #endif
5940 }
5941 {
5942 if (temp1)
5943 delete arg1;
5944 }
5945 {
5946 if (temp2)
5947 delete arg2;
5948 }
5949 return resultobj;
5950 fail:
5951 {
5952 if (temp1)
5953 delete arg1;
5954 }
5955 {
5956 if (temp2)
5957 delete arg2;
5958 }
5959 return NULL;
5960 }
5961
5962
5963 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj = 0;
5965 wxString *arg1 = 0 ;
5966 wxString const &arg2_defvalue = wxPyEmptyString ;
5967 wxString *arg2 = (wxString *) &arg2_defvalue ;
5968 wxString const &arg3_defvalue = wxPyEmptyString ;
5969 wxString *arg3 = (wxString *) &arg3_defvalue ;
5970 wxWindow *arg4 = (wxWindow *) NULL ;
5971 int arg5 = (int) -1 ;
5972 int arg6 = (int) -1 ;
5973 bool arg7 = (bool) true ;
5974 wxString result;
5975 bool temp1 = false ;
5976 bool temp2 = false ;
5977 bool temp3 = false ;
5978 void *argp4 = 0 ;
5979 int res4 = 0 ;
5980 int val5 ;
5981 int ecode5 = 0 ;
5982 int val6 ;
5983 int ecode6 = 0 ;
5984 bool val7 ;
5985 int ecode7 = 0 ;
5986 PyObject * obj0 = 0 ;
5987 PyObject * obj1 = 0 ;
5988 PyObject * obj2 = 0 ;
5989 PyObject * obj3 = 0 ;
5990 PyObject * obj4 = 0 ;
5991 PyObject * obj5 = 0 ;
5992 PyObject * obj6 = 0 ;
5993 char * kwnames[] = {
5994 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5995 };
5996
5997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5998 {
5999 arg1 = wxString_in_helper(obj0);
6000 if (arg1 == NULL) SWIG_fail;
6001 temp1 = true;
6002 }
6003 if (obj1) {
6004 {
6005 arg2 = wxString_in_helper(obj1);
6006 if (arg2 == NULL) SWIG_fail;
6007 temp2 = true;
6008 }
6009 }
6010 if (obj2) {
6011 {
6012 arg3 = wxString_in_helper(obj2);
6013 if (arg3 == NULL) SWIG_fail;
6014 temp3 = true;
6015 }
6016 }
6017 if (obj3) {
6018 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6019 if (!SWIG_IsOK(res4)) {
6020 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6021 }
6022 arg4 = reinterpret_cast< wxWindow * >(argp4);
6023 }
6024 if (obj4) {
6025 ecode5 = SWIG_AsVal_int(obj4, &val5);
6026 if (!SWIG_IsOK(ecode5)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6028 }
6029 arg5 = static_cast< int >(val5);
6030 }
6031 if (obj5) {
6032 ecode6 = SWIG_AsVal_int(obj5, &val6);
6033 if (!SWIG_IsOK(ecode6)) {
6034 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6035 }
6036 arg6 = static_cast< int >(val6);
6037 }
6038 if (obj6) {
6039 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6040 if (!SWIG_IsOK(ecode7)) {
6041 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6042 }
6043 arg7 = static_cast< bool >(val7);
6044 }
6045 {
6046 if (!wxPyCheckForApp()) SWIG_fail;
6047 PyThreadState* __tstate = wxPyBeginAllowThreads();
6048 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6049 wxPyEndAllowThreads(__tstate);
6050 if (PyErr_Occurred()) SWIG_fail;
6051 }
6052 {
6053 #if wxUSE_UNICODE
6054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6055 #else
6056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6057 #endif
6058 }
6059 {
6060 if (temp1)
6061 delete arg1;
6062 }
6063 {
6064 if (temp2)
6065 delete arg2;
6066 }
6067 {
6068 if (temp3)
6069 delete arg3;
6070 }
6071 return resultobj;
6072 fail:
6073 {
6074 if (temp1)
6075 delete arg1;
6076 }
6077 {
6078 if (temp2)
6079 delete arg2;
6080 }
6081 {
6082 if (temp3)
6083 delete arg3;
6084 }
6085 return NULL;
6086 }
6087
6088
6089 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6090 PyObject *resultobj = 0;
6091 wxString *arg1 = 0 ;
6092 wxString const &arg2_defvalue = wxPyEmptyString ;
6093 wxString *arg2 = (wxString *) &arg2_defvalue ;
6094 wxString const &arg3_defvalue = wxPyEmptyString ;
6095 wxString *arg3 = (wxString *) &arg3_defvalue ;
6096 wxWindow *arg4 = (wxWindow *) NULL ;
6097 wxString result;
6098 bool temp1 = false ;
6099 bool temp2 = false ;
6100 bool temp3 = false ;
6101 void *argp4 = 0 ;
6102 int res4 = 0 ;
6103 PyObject * obj0 = 0 ;
6104 PyObject * obj1 = 0 ;
6105 PyObject * obj2 = 0 ;
6106 PyObject * obj3 = 0 ;
6107 char * kwnames[] = {
6108 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6109 };
6110
6111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6112 {
6113 arg1 = wxString_in_helper(obj0);
6114 if (arg1 == NULL) SWIG_fail;
6115 temp1 = true;
6116 }
6117 if (obj1) {
6118 {
6119 arg2 = wxString_in_helper(obj1);
6120 if (arg2 == NULL) SWIG_fail;
6121 temp2 = true;
6122 }
6123 }
6124 if (obj2) {
6125 {
6126 arg3 = wxString_in_helper(obj2);
6127 if (arg3 == NULL) SWIG_fail;
6128 temp3 = true;
6129 }
6130 }
6131 if (obj3) {
6132 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6133 if (!SWIG_IsOK(res4)) {
6134 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6135 }
6136 arg4 = reinterpret_cast< wxWindow * >(argp4);
6137 }
6138 {
6139 if (!wxPyCheckForApp()) SWIG_fail;
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 {
6146 #if wxUSE_UNICODE
6147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6148 #else
6149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6150 #endif
6151 }
6152 {
6153 if (temp1)
6154 delete arg1;
6155 }
6156 {
6157 if (temp2)
6158 delete arg2;
6159 }
6160 {
6161 if (temp3)
6162 delete arg3;
6163 }
6164 return resultobj;
6165 fail:
6166 {
6167 if (temp1)
6168 delete arg1;
6169 }
6170 {
6171 if (temp2)
6172 delete arg2;
6173 }
6174 {
6175 if (temp3)
6176 delete arg3;
6177 }
6178 return NULL;
6179 }
6180
6181
6182 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj = 0;
6184 wxString *arg1 = 0 ;
6185 wxString *arg2 = 0 ;
6186 int arg3 ;
6187 wxString *arg4 = (wxString *) 0 ;
6188 wxWindow *arg5 = (wxWindow *) NULL ;
6189 int arg6 = (int) -1 ;
6190 int arg7 = (int) -1 ;
6191 bool arg8 = (bool) true ;
6192 int arg9 = (int) 150 ;
6193 int arg10 = (int) 200 ;
6194 wxString result;
6195 bool temp1 = false ;
6196 bool temp2 = false ;
6197 void *argp5 = 0 ;
6198 int res5 = 0 ;
6199 int val6 ;
6200 int ecode6 = 0 ;
6201 int val7 ;
6202 int ecode7 = 0 ;
6203 bool val8 ;
6204 int ecode8 = 0 ;
6205 int val9 ;
6206 int ecode9 = 0 ;
6207 int val10 ;
6208 int ecode10 = 0 ;
6209 PyObject * obj0 = 0 ;
6210 PyObject * obj1 = 0 ;
6211 PyObject * obj2 = 0 ;
6212 PyObject * obj3 = 0 ;
6213 PyObject * obj4 = 0 ;
6214 PyObject * obj5 = 0 ;
6215 PyObject * obj6 = 0 ;
6216 PyObject * obj7 = 0 ;
6217 PyObject * obj8 = 0 ;
6218 char * kwnames[] = {
6219 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6220 };
6221
6222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6223 {
6224 arg1 = wxString_in_helper(obj0);
6225 if (arg1 == NULL) SWIG_fail;
6226 temp1 = true;
6227 }
6228 {
6229 arg2 = wxString_in_helper(obj1);
6230 if (arg2 == NULL) SWIG_fail;
6231 temp2 = true;
6232 }
6233 {
6234 arg3 = PyList_Size(obj2);
6235 arg4 = wxString_LIST_helper(obj2);
6236 if (arg4 == NULL) SWIG_fail;
6237 }
6238 if (obj3) {
6239 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6240 if (!SWIG_IsOK(res5)) {
6241 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6242 }
6243 arg5 = reinterpret_cast< wxWindow * >(argp5);
6244 }
6245 if (obj4) {
6246 ecode6 = SWIG_AsVal_int(obj4, &val6);
6247 if (!SWIG_IsOK(ecode6)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6249 }
6250 arg6 = static_cast< int >(val6);
6251 }
6252 if (obj5) {
6253 ecode7 = SWIG_AsVal_int(obj5, &val7);
6254 if (!SWIG_IsOK(ecode7)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6256 }
6257 arg7 = static_cast< int >(val7);
6258 }
6259 if (obj6) {
6260 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6261 if (!SWIG_IsOK(ecode8)) {
6262 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6263 }
6264 arg8 = static_cast< bool >(val8);
6265 }
6266 if (obj7) {
6267 ecode9 = SWIG_AsVal_int(obj7, &val9);
6268 if (!SWIG_IsOK(ecode9)) {
6269 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6270 }
6271 arg9 = static_cast< int >(val9);
6272 }
6273 if (obj8) {
6274 ecode10 = SWIG_AsVal_int(obj8, &val10);
6275 if (!SWIG_IsOK(ecode10)) {
6276 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6277 }
6278 arg10 = static_cast< int >(val10);
6279 }
6280 {
6281 if (!wxPyCheckForApp()) SWIG_fail;
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 {
6288 #if wxUSE_UNICODE
6289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6290 #else
6291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6292 #endif
6293 }
6294 {
6295 if (temp1)
6296 delete arg1;
6297 }
6298 {
6299 if (temp2)
6300 delete arg2;
6301 }
6302 {
6303 if (arg4) delete [] arg4;
6304 }
6305 return resultobj;
6306 fail:
6307 {
6308 if (temp1)
6309 delete arg1;
6310 }
6311 {
6312 if (temp2)
6313 delete arg2;
6314 }
6315 {
6316 if (arg4) delete [] arg4;
6317 }
6318 return NULL;
6319 }
6320
6321
6322 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6323 PyObject *resultobj = 0;
6324 wxString *arg1 = 0 ;
6325 wxString *arg2 = 0 ;
6326 int arg3 ;
6327 wxString *arg4 = (wxString *) 0 ;
6328 wxWindow *arg5 = (wxWindow *) NULL ;
6329 int arg6 = (int) -1 ;
6330 int arg7 = (int) -1 ;
6331 bool arg8 = (bool) true ;
6332 int arg9 = (int) 150 ;
6333 int arg10 = (int) 200 ;
6334 int result;
6335 bool temp1 = false ;
6336 bool temp2 = false ;
6337 void *argp5 = 0 ;
6338 int res5 = 0 ;
6339 int val6 ;
6340 int ecode6 = 0 ;
6341 int val7 ;
6342 int ecode7 = 0 ;
6343 bool val8 ;
6344 int ecode8 = 0 ;
6345 int val9 ;
6346 int ecode9 = 0 ;
6347 int val10 ;
6348 int ecode10 = 0 ;
6349 PyObject * obj0 = 0 ;
6350 PyObject * obj1 = 0 ;
6351 PyObject * obj2 = 0 ;
6352 PyObject * obj3 = 0 ;
6353 PyObject * obj4 = 0 ;
6354 PyObject * obj5 = 0 ;
6355 PyObject * obj6 = 0 ;
6356 PyObject * obj7 = 0 ;
6357 PyObject * obj8 = 0 ;
6358 char * kwnames[] = {
6359 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6360 };
6361
6362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6363 {
6364 arg1 = wxString_in_helper(obj0);
6365 if (arg1 == NULL) SWIG_fail;
6366 temp1 = true;
6367 }
6368 {
6369 arg2 = wxString_in_helper(obj1);
6370 if (arg2 == NULL) SWIG_fail;
6371 temp2 = true;
6372 }
6373 {
6374 arg3 = PyList_Size(obj2);
6375 arg4 = wxString_LIST_helper(obj2);
6376 if (arg4 == NULL) SWIG_fail;
6377 }
6378 if (obj3) {
6379 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6380 if (!SWIG_IsOK(res5)) {
6381 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6382 }
6383 arg5 = reinterpret_cast< wxWindow * >(argp5);
6384 }
6385 if (obj4) {
6386 ecode6 = SWIG_AsVal_int(obj4, &val6);
6387 if (!SWIG_IsOK(ecode6)) {
6388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6389 }
6390 arg6 = static_cast< int >(val6);
6391 }
6392 if (obj5) {
6393 ecode7 = SWIG_AsVal_int(obj5, &val7);
6394 if (!SWIG_IsOK(ecode7)) {
6395 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6396 }
6397 arg7 = static_cast< int >(val7);
6398 }
6399 if (obj6) {
6400 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6401 if (!SWIG_IsOK(ecode8)) {
6402 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6403 }
6404 arg8 = static_cast< bool >(val8);
6405 }
6406 if (obj7) {
6407 ecode9 = SWIG_AsVal_int(obj7, &val9);
6408 if (!SWIG_IsOK(ecode9)) {
6409 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6410 }
6411 arg9 = static_cast< int >(val9);
6412 }
6413 if (obj8) {
6414 ecode10 = SWIG_AsVal_int(obj8, &val10);
6415 if (!SWIG_IsOK(ecode10)) {
6416 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6417 }
6418 arg10 = static_cast< int >(val10);
6419 }
6420 {
6421 if (!wxPyCheckForApp()) SWIG_fail;
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6424 wxPyEndAllowThreads(__tstate);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 resultobj = SWIG_From_int(static_cast< int >(result));
6428 {
6429 if (temp1)
6430 delete arg1;
6431 }
6432 {
6433 if (temp2)
6434 delete arg2;
6435 }
6436 {
6437 if (arg4) delete [] arg4;
6438 }
6439 return resultobj;
6440 fail:
6441 {
6442 if (temp1)
6443 delete arg1;
6444 }
6445 {
6446 if (temp2)
6447 delete arg2;
6448 }
6449 {
6450 if (arg4) delete [] arg4;
6451 }
6452 return NULL;
6453 }
6454
6455
6456 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj = 0;
6458 wxString *arg1 = 0 ;
6459 wxString const &arg2_defvalue = wxPyEmptyString ;
6460 wxString *arg2 = (wxString *) &arg2_defvalue ;
6461 int arg3 = (int) wxOK|wxCENTRE ;
6462 wxWindow *arg4 = (wxWindow *) NULL ;
6463 int arg5 = (int) -1 ;
6464 int arg6 = (int) -1 ;
6465 int result;
6466 bool temp1 = false ;
6467 bool temp2 = false ;
6468 int val3 ;
6469 int ecode3 = 0 ;
6470 void *argp4 = 0 ;
6471 int res4 = 0 ;
6472 int val5 ;
6473 int ecode5 = 0 ;
6474 int val6 ;
6475 int ecode6 = 0 ;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 PyObject * obj2 = 0 ;
6479 PyObject * obj3 = 0 ;
6480 PyObject * obj4 = 0 ;
6481 PyObject * obj5 = 0 ;
6482 char * kwnames[] = {
6483 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6484 };
6485
6486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6487 {
6488 arg1 = wxString_in_helper(obj0);
6489 if (arg1 == NULL) SWIG_fail;
6490 temp1 = true;
6491 }
6492 if (obj1) {
6493 {
6494 arg2 = wxString_in_helper(obj1);
6495 if (arg2 == NULL) SWIG_fail;
6496 temp2 = true;
6497 }
6498 }
6499 if (obj2) {
6500 ecode3 = SWIG_AsVal_int(obj2, &val3);
6501 if (!SWIG_IsOK(ecode3)) {
6502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6503 }
6504 arg3 = static_cast< int >(val3);
6505 }
6506 if (obj3) {
6507 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6508 if (!SWIG_IsOK(res4)) {
6509 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6510 }
6511 arg4 = reinterpret_cast< wxWindow * >(argp4);
6512 }
6513 if (obj4) {
6514 ecode5 = SWIG_AsVal_int(obj4, &val5);
6515 if (!SWIG_IsOK(ecode5)) {
6516 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6517 }
6518 arg5 = static_cast< int >(val5);
6519 }
6520 if (obj5) {
6521 ecode6 = SWIG_AsVal_int(obj5, &val6);
6522 if (!SWIG_IsOK(ecode6)) {
6523 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6524 }
6525 arg6 = static_cast< int >(val6);
6526 }
6527 {
6528 if (!wxPyCheckForApp()) SWIG_fail;
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_From_int(static_cast< int >(result));
6535 {
6536 if (temp1)
6537 delete arg1;
6538 }
6539 {
6540 if (temp2)
6541 delete arg2;
6542 }
6543 return resultobj;
6544 fail:
6545 {
6546 if (temp1)
6547 delete arg1;
6548 }
6549 {
6550 if (temp2)
6551 delete arg2;
6552 }
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxString *arg1 = 0 ;
6560 wxString *arg2 = 0 ;
6561 wxString *arg3 = 0 ;
6562 long arg4 ;
6563 long arg5 = (long) 0 ;
6564 long arg6 = (long) 100 ;
6565 wxWindow *arg7 = (wxWindow *) NULL ;
6566 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6567 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6568 long result;
6569 bool temp1 = false ;
6570 bool temp2 = false ;
6571 bool temp3 = false ;
6572 long val4 ;
6573 int ecode4 = 0 ;
6574 long val5 ;
6575 int ecode5 = 0 ;
6576 long val6 ;
6577 int ecode6 = 0 ;
6578 void *argp7 = 0 ;
6579 int res7 = 0 ;
6580 wxPoint temp8 ;
6581 PyObject * obj0 = 0 ;
6582 PyObject * obj1 = 0 ;
6583 PyObject * obj2 = 0 ;
6584 PyObject * obj3 = 0 ;
6585 PyObject * obj4 = 0 ;
6586 PyObject * obj5 = 0 ;
6587 PyObject * obj6 = 0 ;
6588 PyObject * obj7 = 0 ;
6589 char * kwnames[] = {
6590 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6591 };
6592
6593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6594 {
6595 arg1 = wxString_in_helper(obj0);
6596 if (arg1 == NULL) SWIG_fail;
6597 temp1 = true;
6598 }
6599 {
6600 arg2 = wxString_in_helper(obj1);
6601 if (arg2 == NULL) SWIG_fail;
6602 temp2 = true;
6603 }
6604 {
6605 arg3 = wxString_in_helper(obj2);
6606 if (arg3 == NULL) SWIG_fail;
6607 temp3 = true;
6608 }
6609 ecode4 = SWIG_AsVal_long(obj3, &val4);
6610 if (!SWIG_IsOK(ecode4)) {
6611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6612 }
6613 arg4 = static_cast< long >(val4);
6614 if (obj4) {
6615 ecode5 = SWIG_AsVal_long(obj4, &val5);
6616 if (!SWIG_IsOK(ecode5)) {
6617 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6618 }
6619 arg5 = static_cast< long >(val5);
6620 }
6621 if (obj5) {
6622 ecode6 = SWIG_AsVal_long(obj5, &val6);
6623 if (!SWIG_IsOK(ecode6)) {
6624 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6625 }
6626 arg6 = static_cast< long >(val6);
6627 }
6628 if (obj6) {
6629 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6630 if (!SWIG_IsOK(res7)) {
6631 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6632 }
6633 arg7 = reinterpret_cast< wxWindow * >(argp7);
6634 }
6635 if (obj7) {
6636 {
6637 arg8 = &temp8;
6638 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6639 }
6640 }
6641 {
6642 if (!wxPyCheckForApp()) SWIG_fail;
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6645 wxPyEndAllowThreads(__tstate);
6646 if (PyErr_Occurred()) SWIG_fail;
6647 }
6648 resultobj = SWIG_From_long(static_cast< long >(result));
6649 {
6650 if (temp1)
6651 delete arg1;
6652 }
6653 {
6654 if (temp2)
6655 delete arg2;
6656 }
6657 {
6658 if (temp3)
6659 delete arg3;
6660 }
6661 return resultobj;
6662 fail:
6663 {
6664 if (temp1)
6665 delete arg1;
6666 }
6667 {
6668 if (temp2)
6669 delete arg2;
6670 }
6671 {
6672 if (temp3)
6673 delete arg3;
6674 }
6675 return NULL;
6676 }
6677
6678
6679 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6680 PyObject *resultobj = 0;
6681 bool result;
6682
6683 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6684 {
6685 if (!wxPyCheckForApp()) SWIG_fail;
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)wxColourDisplay();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 int result;
6703
6704 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6705 {
6706 if (!wxPyCheckForApp()) SWIG_fail;
6707 PyThreadState* __tstate = wxPyBeginAllowThreads();
6708 result = (int)wxDisplayDepth();
6709 wxPyEndAllowThreads(__tstate);
6710 if (PyErr_Occurred()) SWIG_fail;
6711 }
6712 resultobj = SWIG_From_int(static_cast< int >(result));
6713 return resultobj;
6714 fail:
6715 return NULL;
6716 }
6717
6718
6719 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6720 PyObject *resultobj = 0;
6721 int result;
6722
6723 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6724 {
6725 if (!wxPyCheckForApp()) SWIG_fail;
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (int)wxGetDisplayDepth();
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 resultobj = SWIG_From_int(static_cast< int >(result));
6732 return resultobj;
6733 fail:
6734 return NULL;
6735 }
6736
6737
6738 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6739 PyObject *resultobj = 0;
6740 int *arg1 = (int *) 0 ;
6741 int *arg2 = (int *) 0 ;
6742 int temp1 ;
6743 int res1 = SWIG_TMPOBJ ;
6744 int temp2 ;
6745 int res2 = SWIG_TMPOBJ ;
6746
6747 arg1 = &temp1;
6748 arg2 = &temp2;
6749 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6750 {
6751 if (!wxPyCheckForApp()) SWIG_fail;
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 wxDisplaySize(arg1,arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 if (SWIG_IsTmpObj(res1)) {
6759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6760 } else {
6761 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6763 }
6764 if (SWIG_IsTmpObj(res2)) {
6765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6766 } else {
6767 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6769 }
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6777 PyObject *resultobj = 0;
6778 wxSize result;
6779
6780 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6781 {
6782 if (!wxPyCheckForApp()) SWIG_fail;
6783 PyThreadState* __tstate = wxPyBeginAllowThreads();
6784 result = wxGetDisplaySize();
6785 wxPyEndAllowThreads(__tstate);
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6796 PyObject *resultobj = 0;
6797 int *arg1 = (int *) 0 ;
6798 int *arg2 = (int *) 0 ;
6799 int temp1 ;
6800 int res1 = SWIG_TMPOBJ ;
6801 int temp2 ;
6802 int res2 = SWIG_TMPOBJ ;
6803
6804 arg1 = &temp1;
6805 arg2 = &temp2;
6806 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6807 {
6808 if (!wxPyCheckForApp()) SWIG_fail;
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 wxDisplaySizeMM(arg1,arg2);
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 resultobj = SWIG_Py_Void();
6815 if (SWIG_IsTmpObj(res1)) {
6816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6817 } else {
6818 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6820 }
6821 if (SWIG_IsTmpObj(res2)) {
6822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6823 } else {
6824 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6826 }
6827 return resultobj;
6828 fail:
6829 return NULL;
6830 }
6831
6832
6833 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6834 PyObject *resultobj = 0;
6835 wxSize result;
6836
6837 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6838 {
6839 if (!wxPyCheckForApp()) SWIG_fail;
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = wxGetDisplaySizeMM();
6842 wxPyEndAllowThreads(__tstate);
6843 if (PyErr_Occurred()) SWIG_fail;
6844 }
6845 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6846 return resultobj;
6847 fail:
6848 return NULL;
6849 }
6850
6851
6852 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6853 PyObject *resultobj = 0;
6854 int *arg1 = (int *) 0 ;
6855 int *arg2 = (int *) 0 ;
6856 int *arg3 = (int *) 0 ;
6857 int *arg4 = (int *) 0 ;
6858 int temp1 ;
6859 int res1 = SWIG_TMPOBJ ;
6860 int temp2 ;
6861 int res2 = SWIG_TMPOBJ ;
6862 int temp3 ;
6863 int res3 = SWIG_TMPOBJ ;
6864 int temp4 ;
6865 int res4 = SWIG_TMPOBJ ;
6866
6867 arg1 = &temp1;
6868 arg2 = &temp2;
6869 arg3 = &temp3;
6870 arg4 = &temp4;
6871 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6872 {
6873 if (!wxPyCheckForApp()) SWIG_fail;
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 resultobj = SWIG_Py_Void();
6880 if (SWIG_IsTmpObj(res1)) {
6881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6882 } else {
6883 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6885 }
6886 if (SWIG_IsTmpObj(res2)) {
6887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6888 } else {
6889 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6891 }
6892 if (SWIG_IsTmpObj(res3)) {
6893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6894 } else {
6895 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6897 }
6898 if (SWIG_IsTmpObj(res4)) {
6899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6900 } else {
6901 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6903 }
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6911 PyObject *resultobj = 0;
6912 wxRect result;
6913
6914 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6915 {
6916 if (!wxPyCheckForApp()) SWIG_fail;
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 result = wxGetClientDisplayRect();
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = 0;
6931 wxCursor *arg1 = 0 ;
6932 void *argp1 = 0 ;
6933 int res1 = 0 ;
6934 PyObject * obj0 = 0 ;
6935 char * kwnames[] = {
6936 (char *) "cursor", NULL
6937 };
6938
6939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6940 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6941 if (!SWIG_IsOK(res1)) {
6942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6943 }
6944 if (!argp1) {
6945 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6946 }
6947 arg1 = reinterpret_cast< wxCursor * >(argp1);
6948 {
6949 if (!wxPyCheckForApp()) SWIG_fail;
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 wxSetCursor(*arg1);
6952 wxPyEndAllowThreads(__tstate);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 resultobj = SWIG_Py_Void();
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6963 PyObject *resultobj = 0;
6964 void *result = 0 ;
6965
6966 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6967 {
6968 if (!wxPyCheckForApp()) SWIG_fail;
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 result = (void *)wxGetXDisplay();
6971 wxPyEndAllowThreads(__tstate);
6972 if (PyErr_Occurred()) SWIG_fail;
6973 }
6974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6975 return resultobj;
6976 fail:
6977 return NULL;
6978 }
6979
6980
6981 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6982 PyObject *resultobj = 0;
6983 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6984 void *argp1 = 0 ;
6985 int res1 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "cursor", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6992 if (obj0) {
6993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6996 }
6997 arg1 = reinterpret_cast< wxCursor * >(argp1);
6998 }
6999 {
7000 if (!wxPyCheckForApp()) SWIG_fail;
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 wxBeginBusyCursor(arg1);
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_Py_Void();
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7014 PyObject *resultobj = 0;
7015 wxPoint result;
7016
7017 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7018 {
7019 if (!wxPyCheckForApp()) SWIG_fail;
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = wxGetMousePosition();
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7026 return resultobj;
7027 fail:
7028 return NULL;
7029 }
7030
7031
7032 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7033 PyObject *resultobj = 0;
7034 wxWindow *result = 0 ;
7035
7036 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7037 {
7038 if (!wxPyCheckForApp()) SWIG_fail;
7039 PyThreadState* __tstate = wxPyBeginAllowThreads();
7040 result = (wxWindow *)FindWindowAtPointer();
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 {
7045 resultobj = wxPyMake_wxObject(result, 0);
7046 }
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7054 PyObject *resultobj = 0;
7055 wxWindow *result = 0 ;
7056
7057 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7058 {
7059 if (!wxPyCheckForApp()) SWIG_fail;
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 result = (wxWindow *)wxGetActiveWindow();
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 {
7066 resultobj = wxPyMake_wxObject(result, 0);
7067 }
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7075 PyObject *resultobj = 0;
7076 wxPoint *arg1 = 0 ;
7077 wxWindow *result = 0 ;
7078 wxPoint temp1 ;
7079 PyObject * obj0 = 0 ;
7080 char * kwnames[] = {
7081 (char *) "pt", NULL
7082 };
7083
7084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7085 {
7086 arg1 = &temp1;
7087 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7088 }
7089 {
7090 if (!wxPyCheckForApp()) SWIG_fail;
7091 PyThreadState* __tstate = wxPyBeginAllowThreads();
7092 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7093 wxPyEndAllowThreads(__tstate);
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 {
7097 resultobj = wxPyMake_wxObject(result, 0);
7098 }
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7106 PyObject *resultobj = 0;
7107 wxPoint *arg1 = 0 ;
7108 wxWindow *result = 0 ;
7109 wxPoint temp1 ;
7110 PyObject * obj0 = 0 ;
7111 char * kwnames[] = {
7112 (char *) "pt", NULL
7113 };
7114
7115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7116 {
7117 arg1 = &temp1;
7118 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7119 }
7120 {
7121 if (!wxPyCheckForApp()) SWIG_fail;
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 {
7128 resultobj = wxPyMake_wxObject(result, 0);
7129 }
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj = 0;
7138 wxWindow *arg1 = (wxWindow *) 0 ;
7139 wxWindow *result = 0 ;
7140 void *argp1 = 0 ;
7141 int res1 = 0 ;
7142 PyObject * obj0 = 0 ;
7143 char * kwnames[] = {
7144 (char *) "win", NULL
7145 };
7146
7147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7149 if (!SWIG_IsOK(res1)) {
7150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7151 }
7152 arg1 = reinterpret_cast< wxWindow * >(argp1);
7153 {
7154 if (!wxPyCheckForApp()) SWIG_fail;
7155 PyThreadState* __tstate = wxPyBeginAllowThreads();
7156 result = (wxWindow *)wxGetTopLevelParent(arg1);
7157 wxPyEndAllowThreads(__tstate);
7158 if (PyErr_Occurred()) SWIG_fail;
7159 }
7160 {
7161 resultobj = wxPyMake_wxObject(result, 0);
7162 }
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj = 0;
7171 wxString *arg1 = 0 ;
7172 bool result;
7173 bool temp1 = false ;
7174 PyObject * obj0 = 0 ;
7175 char * kwnames[] = {
7176 (char *) "url", NULL
7177 };
7178
7179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7180 {
7181 arg1 = wxString_in_helper(obj0);
7182 if (arg1 == NULL) SWIG_fail;
7183 temp1 = true;
7184 }
7185 {
7186 PyThreadState* __tstate = wxPyBeginAllowThreads();
7187 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7188 wxPyEndAllowThreads(__tstate);
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 {
7192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7193 }
7194 {
7195 if (temp1)
7196 delete arg1;
7197 }
7198 return resultobj;
7199 fail:
7200 {
7201 if (temp1)
7202 delete arg1;
7203 }
7204 return NULL;
7205 }
7206
7207
7208 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7209 PyObject *resultobj = 0;
7210 wxKeyCode arg1 ;
7211 bool result;
7212 int val1 ;
7213 int ecode1 = 0 ;
7214 PyObject * obj0 = 0 ;
7215 char * kwnames[] = {
7216 (char *) "key", NULL
7217 };
7218
7219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7220 ecode1 = SWIG_AsVal_int(obj0, &val1);
7221 if (!SWIG_IsOK(ecode1)) {
7222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7223 }
7224 arg1 = static_cast< wxKeyCode >(val1);
7225 {
7226 if (!wxPyCheckForApp()) SWIG_fail;
7227 PyThreadState* __tstate = wxPyBeginAllowThreads();
7228 result = (bool)wxGetKeyState(arg1);
7229 wxPyEndAllowThreads(__tstate);
7230 if (PyErr_Occurred()) SWIG_fail;
7231 }
7232 {
7233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7234 }
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7242 PyObject *resultobj = 0;
7243 wxMouseState *result = 0 ;
7244
7245 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (wxMouseState *)new wxMouseState();
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7260 PyObject *resultobj = 0;
7261 wxMouseState *arg1 = (wxMouseState *) 0 ;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 PyObject *swig_obj[1] ;
7265
7266 if (!args) SWIG_fail;
7267 swig_obj[0] = args;
7268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7269 if (!SWIG_IsOK(res1)) {
7270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7271 }
7272 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7273 {
7274 PyThreadState* __tstate = wxPyBeginAllowThreads();
7275 delete arg1;
7276
7277 wxPyEndAllowThreads(__tstate);
7278 if (PyErr_Occurred()) SWIG_fail;
7279 }
7280 resultobj = SWIG_Py_Void();
7281 return resultobj;
7282 fail:
7283 return NULL;
7284 }
7285
7286
7287 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7288 PyObject *resultobj = 0;
7289 wxMouseState *arg1 = (wxMouseState *) 0 ;
7290 int result;
7291 void *argp1 = 0 ;
7292 int res1 = 0 ;
7293 PyObject *swig_obj[1] ;
7294
7295 if (!args) SWIG_fail;
7296 swig_obj[0] = args;
7297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7298 if (!SWIG_IsOK(res1)) {
7299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7300 }
7301 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 result = (int)(arg1)->GetX();
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 resultobj = SWIG_From_int(static_cast< int >(result));
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7316 PyObject *resultobj = 0;
7317 wxMouseState *arg1 = (wxMouseState *) 0 ;
7318 int result;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 PyObject *swig_obj[1] ;
7322
7323 if (!args) SWIG_fail;
7324 swig_obj[0] = args;
7325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7328 }
7329 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7330 {
7331 PyThreadState* __tstate = wxPyBeginAllowThreads();
7332 result = (int)(arg1)->GetY();
7333 wxPyEndAllowThreads(__tstate);
7334 if (PyErr_Occurred()) SWIG_fail;
7335 }
7336 resultobj = SWIG_From_int(static_cast< int >(result));
7337 return resultobj;
7338 fail:
7339 return NULL;
7340 }
7341
7342
7343 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7344 PyObject *resultobj = 0;
7345 wxMouseState *arg1 = (wxMouseState *) 0 ;
7346 bool result;
7347 void *argp1 = 0 ;
7348 int res1 = 0 ;
7349 PyObject *swig_obj[1] ;
7350
7351 if (!args) SWIG_fail;
7352 swig_obj[0] = args;
7353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7354 if (!SWIG_IsOK(res1)) {
7355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7356 }
7357 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 result = (bool)(arg1)->LeftDown();
7361 wxPyEndAllowThreads(__tstate);
7362 if (PyErr_Occurred()) SWIG_fail;
7363 }
7364 {
7365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7366 }
7367 return resultobj;
7368 fail:
7369 return NULL;
7370 }
7371
7372
7373 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7374 PyObject *resultobj = 0;
7375 wxMouseState *arg1 = (wxMouseState *) 0 ;
7376 bool result;
7377 void *argp1 = 0 ;
7378 int res1 = 0 ;
7379 PyObject *swig_obj[1] ;
7380
7381 if (!args) SWIG_fail;
7382 swig_obj[0] = args;
7383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7384 if (!SWIG_IsOK(res1)) {
7385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7386 }
7387 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7388 {
7389 PyThreadState* __tstate = wxPyBeginAllowThreads();
7390 result = (bool)(arg1)->MiddleDown();
7391 wxPyEndAllowThreads(__tstate);
7392 if (PyErr_Occurred()) SWIG_fail;
7393 }
7394 {
7395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7396 }
7397 return resultobj;
7398 fail:
7399 return NULL;
7400 }
7401
7402
7403 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7404 PyObject *resultobj = 0;
7405 wxMouseState *arg1 = (wxMouseState *) 0 ;
7406 bool result;
7407 void *argp1 = 0 ;
7408 int res1 = 0 ;
7409 PyObject *swig_obj[1] ;
7410
7411 if (!args) SWIG_fail;
7412 swig_obj[0] = args;
7413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7416 }
7417 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 result = (bool)(arg1)->RightDown();
7421 wxPyEndAllowThreads(__tstate);
7422 if (PyErr_Occurred()) SWIG_fail;
7423 }
7424 {
7425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7426 }
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7434 PyObject *resultobj = 0;
7435 wxMouseState *arg1 = (wxMouseState *) 0 ;
7436 bool result;
7437 void *argp1 = 0 ;
7438 int res1 = 0 ;
7439 PyObject *swig_obj[1] ;
7440
7441 if (!args) SWIG_fail;
7442 swig_obj[0] = args;
7443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7444 if (!SWIG_IsOK(res1)) {
7445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7446 }
7447 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)(arg1)->ControlDown();
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7464 PyObject *resultobj = 0;
7465 wxMouseState *arg1 = (wxMouseState *) 0 ;
7466 bool result;
7467 void *argp1 = 0 ;
7468 int res1 = 0 ;
7469 PyObject *swig_obj[1] ;
7470
7471 if (!args) SWIG_fail;
7472 swig_obj[0] = args;
7473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7474 if (!SWIG_IsOK(res1)) {
7475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7476 }
7477 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7478 {
7479 PyThreadState* __tstate = wxPyBeginAllowThreads();
7480 result = (bool)(arg1)->ShiftDown();
7481 wxPyEndAllowThreads(__tstate);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7494 PyObject *resultobj = 0;
7495 wxMouseState *arg1 = (wxMouseState *) 0 ;
7496 bool result;
7497 void *argp1 = 0 ;
7498 int res1 = 0 ;
7499 PyObject *swig_obj[1] ;
7500
7501 if (!args) SWIG_fail;
7502 swig_obj[0] = args;
7503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7504 if (!SWIG_IsOK(res1)) {
7505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7506 }
7507 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7508 {
7509 PyThreadState* __tstate = wxPyBeginAllowThreads();
7510 result = (bool)(arg1)->AltDown();
7511 wxPyEndAllowThreads(__tstate);
7512 if (PyErr_Occurred()) SWIG_fail;
7513 }
7514 {
7515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7516 }
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7524 PyObject *resultobj = 0;
7525 wxMouseState *arg1 = (wxMouseState *) 0 ;
7526 bool result;
7527 void *argp1 = 0 ;
7528 int res1 = 0 ;
7529 PyObject *swig_obj[1] ;
7530
7531 if (!args) SWIG_fail;
7532 swig_obj[0] = args;
7533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7534 if (!SWIG_IsOK(res1)) {
7535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7536 }
7537 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7538 {
7539 PyThreadState* __tstate = wxPyBeginAllowThreads();
7540 result = (bool)(arg1)->MetaDown();
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 {
7545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7546 }
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7554 PyObject *resultobj = 0;
7555 wxMouseState *arg1 = (wxMouseState *) 0 ;
7556 bool result;
7557 void *argp1 = 0 ;
7558 int res1 = 0 ;
7559 PyObject *swig_obj[1] ;
7560
7561 if (!args) SWIG_fail;
7562 swig_obj[0] = args;
7563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7564 if (!SWIG_IsOK(res1)) {
7565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7566 }
7567 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (bool)(arg1)->CmdDown();
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = 0;
7585 wxMouseState *arg1 = (wxMouseState *) 0 ;
7586 int arg2 ;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 int val2 ;
7590 int ecode2 = 0 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "x", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7601 }
7602 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7603 ecode2 = SWIG_AsVal_int(obj1, &val2);
7604 if (!SWIG_IsOK(ecode2)) {
7605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7606 }
7607 arg2 = static_cast< int >(val2);
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 (arg1)->SetX(arg2);
7611 wxPyEndAllowThreads(__tstate);
7612 if (PyErr_Occurred()) SWIG_fail;
7613 }
7614 resultobj = SWIG_Py_Void();
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj = 0;
7623 wxMouseState *arg1 = (wxMouseState *) 0 ;
7624 int arg2 ;
7625 void *argp1 = 0 ;
7626 int res1 = 0 ;
7627 int val2 ;
7628 int ecode2 = 0 ;
7629 PyObject * obj0 = 0 ;
7630 PyObject * obj1 = 0 ;
7631 char * kwnames[] = {
7632 (char *) "self",(char *) "y", NULL
7633 };
7634
7635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7637 if (!SWIG_IsOK(res1)) {
7638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7639 }
7640 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7641 ecode2 = SWIG_AsVal_int(obj1, &val2);
7642 if (!SWIG_IsOK(ecode2)) {
7643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7644 }
7645 arg2 = static_cast< int >(val2);
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 (arg1)->SetY(arg2);
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 resultobj = SWIG_Py_Void();
7653 return resultobj;
7654 fail:
7655 return NULL;
7656 }
7657
7658
7659 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7660 PyObject *resultobj = 0;
7661 wxMouseState *arg1 = (wxMouseState *) 0 ;
7662 bool arg2 ;
7663 void *argp1 = 0 ;
7664 int res1 = 0 ;
7665 bool val2 ;
7666 int ecode2 = 0 ;
7667 PyObject * obj0 = 0 ;
7668 PyObject * obj1 = 0 ;
7669 char * kwnames[] = {
7670 (char *) "self",(char *) "down", NULL
7671 };
7672
7673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7675 if (!SWIG_IsOK(res1)) {
7676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7677 }
7678 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7679 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7680 if (!SWIG_IsOK(ecode2)) {
7681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7682 }
7683 arg2 = static_cast< bool >(val2);
7684 {
7685 PyThreadState* __tstate = wxPyBeginAllowThreads();
7686 (arg1)->SetLeftDown(arg2);
7687 wxPyEndAllowThreads(__tstate);
7688 if (PyErr_Occurred()) SWIG_fail;
7689 }
7690 resultobj = SWIG_Py_Void();
7691 return resultobj;
7692 fail:
7693 return NULL;
7694 }
7695
7696
7697 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7698 PyObject *resultobj = 0;
7699 wxMouseState *arg1 = (wxMouseState *) 0 ;
7700 bool arg2 ;
7701 void *argp1 = 0 ;
7702 int res1 = 0 ;
7703 bool val2 ;
7704 int ecode2 = 0 ;
7705 PyObject * obj0 = 0 ;
7706 PyObject * obj1 = 0 ;
7707 char * kwnames[] = {
7708 (char *) "self",(char *) "down", NULL
7709 };
7710
7711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7713 if (!SWIG_IsOK(res1)) {
7714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7715 }
7716 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7717 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7718 if (!SWIG_IsOK(ecode2)) {
7719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7720 }
7721 arg2 = static_cast< bool >(val2);
7722 {
7723 PyThreadState* __tstate = wxPyBeginAllowThreads();
7724 (arg1)->SetMiddleDown(arg2);
7725 wxPyEndAllowThreads(__tstate);
7726 if (PyErr_Occurred()) SWIG_fail;
7727 }
7728 resultobj = SWIG_Py_Void();
7729 return resultobj;
7730 fail:
7731 return NULL;
7732 }
7733
7734
7735 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7736 PyObject *resultobj = 0;
7737 wxMouseState *arg1 = (wxMouseState *) 0 ;
7738 bool arg2 ;
7739 void *argp1 = 0 ;
7740 int res1 = 0 ;
7741 bool val2 ;
7742 int ecode2 = 0 ;
7743 PyObject * obj0 = 0 ;
7744 PyObject * obj1 = 0 ;
7745 char * kwnames[] = {
7746 (char *) "self",(char *) "down", NULL
7747 };
7748
7749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7751 if (!SWIG_IsOK(res1)) {
7752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7753 }
7754 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7756 if (!SWIG_IsOK(ecode2)) {
7757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7758 }
7759 arg2 = static_cast< bool >(val2);
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 (arg1)->SetRightDown(arg2);
7763 wxPyEndAllowThreads(__tstate);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 resultobj = SWIG_Py_Void();
7767 return resultobj;
7768 fail:
7769 return NULL;
7770 }
7771
7772
7773 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7774 PyObject *resultobj = 0;
7775 wxMouseState *arg1 = (wxMouseState *) 0 ;
7776 bool arg2 ;
7777 void *argp1 = 0 ;
7778 int res1 = 0 ;
7779 bool val2 ;
7780 int ecode2 = 0 ;
7781 PyObject * obj0 = 0 ;
7782 PyObject * obj1 = 0 ;
7783 char * kwnames[] = {
7784 (char *) "self",(char *) "down", NULL
7785 };
7786
7787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7789 if (!SWIG_IsOK(res1)) {
7790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7791 }
7792 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7793 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7794 if (!SWIG_IsOK(ecode2)) {
7795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7796 }
7797 arg2 = static_cast< bool >(val2);
7798 {
7799 PyThreadState* __tstate = wxPyBeginAllowThreads();
7800 (arg1)->SetControlDown(arg2);
7801 wxPyEndAllowThreads(__tstate);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 resultobj = SWIG_Py_Void();
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj = 0;
7813 wxMouseState *arg1 = (wxMouseState *) 0 ;
7814 bool arg2 ;
7815 void *argp1 = 0 ;
7816 int res1 = 0 ;
7817 bool val2 ;
7818 int ecode2 = 0 ;
7819 PyObject * obj0 = 0 ;
7820 PyObject * obj1 = 0 ;
7821 char * kwnames[] = {
7822 (char *) "self",(char *) "down", NULL
7823 };
7824
7825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7829 }
7830 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7831 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7834 }
7835 arg2 = static_cast< bool >(val2);
7836 {
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 (arg1)->SetShiftDown(arg2);
7839 wxPyEndAllowThreads(__tstate);
7840 if (PyErr_Occurred()) SWIG_fail;
7841 }
7842 resultobj = SWIG_Py_Void();
7843 return resultobj;
7844 fail:
7845 return NULL;
7846 }
7847
7848
7849 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7850 PyObject *resultobj = 0;
7851 wxMouseState *arg1 = (wxMouseState *) 0 ;
7852 bool arg2 ;
7853 void *argp1 = 0 ;
7854 int res1 = 0 ;
7855 bool val2 ;
7856 int ecode2 = 0 ;
7857 PyObject * obj0 = 0 ;
7858 PyObject * obj1 = 0 ;
7859 char * kwnames[] = {
7860 (char *) "self",(char *) "down", NULL
7861 };
7862
7863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7865 if (!SWIG_IsOK(res1)) {
7866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7867 }
7868 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7870 if (!SWIG_IsOK(ecode2)) {
7871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7872 }
7873 arg2 = static_cast< bool >(val2);
7874 {
7875 PyThreadState* __tstate = wxPyBeginAllowThreads();
7876 (arg1)->SetAltDown(arg2);
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = SWIG_Py_Void();
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj = 0;
7889 wxMouseState *arg1 = (wxMouseState *) 0 ;
7890 bool arg2 ;
7891 void *argp1 = 0 ;
7892 int res1 = 0 ;
7893 bool val2 ;
7894 int ecode2 = 0 ;
7895 PyObject * obj0 = 0 ;
7896 PyObject * obj1 = 0 ;
7897 char * kwnames[] = {
7898 (char *) "self",(char *) "down", NULL
7899 };
7900
7901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7903 if (!SWIG_IsOK(res1)) {
7904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7905 }
7906 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7907 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7908 if (!SWIG_IsOK(ecode2)) {
7909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7910 }
7911 arg2 = static_cast< bool >(val2);
7912 {
7913 PyThreadState* __tstate = wxPyBeginAllowThreads();
7914 (arg1)->SetMetaDown(arg2);
7915 wxPyEndAllowThreads(__tstate);
7916 if (PyErr_Occurred()) SWIG_fail;
7917 }
7918 resultobj = SWIG_Py_Void();
7919 return resultobj;
7920 fail:
7921 return NULL;
7922 }
7923
7924
7925 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7926 PyObject *obj;
7927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7928 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7929 return SWIG_Py_Void();
7930 }
7931
7932 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7933 return SWIG_Python_InitShadowInstance(args);
7934 }
7935
7936 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7937 PyObject *resultobj = 0;
7938 wxMouseState result;
7939
7940 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7941 {
7942 PyThreadState* __tstate = wxPyBeginAllowThreads();
7943 result = wxGetMouseState();
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7948 return resultobj;
7949 fail:
7950 return NULL;
7951 }
7952
7953
7954 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7955 PyObject *resultobj = 0;
7956
7957 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7958 {
7959 if (!wxPyCheckForApp()) SWIG_fail;
7960 PyThreadState* __tstate = wxPyBeginAllowThreads();
7961 wxWakeUpMainThread();
7962 wxPyEndAllowThreads(__tstate);
7963 if (PyErr_Occurred()) SWIG_fail;
7964 }
7965 resultobj = SWIG_Py_Void();
7966 return resultobj;
7967 fail:
7968 return NULL;
7969 }
7970
7971
7972 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7973 PyObject *resultobj = 0;
7974
7975 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7976 {
7977 if (!wxPyCheckForApp()) SWIG_fail;
7978 PyThreadState* __tstate = wxPyBeginAllowThreads();
7979 wxMutexGuiEnter();
7980 wxPyEndAllowThreads(__tstate);
7981 if (PyErr_Occurred()) SWIG_fail;
7982 }
7983 resultobj = SWIG_Py_Void();
7984 return resultobj;
7985 fail:
7986 return NULL;
7987 }
7988
7989
7990 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7991 PyObject *resultobj = 0;
7992
7993 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7994 {
7995 if (!wxPyCheckForApp()) SWIG_fail;
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 wxMutexGuiLeave();
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 resultobj = SWIG_Py_Void();
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8009 PyObject *resultobj = 0;
8010 wxMutexGuiLocker *result = 0 ;
8011
8012 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8013 {
8014 if (!wxPyCheckForApp()) SWIG_fail;
8015 PyThreadState* __tstate = wxPyBeginAllowThreads();
8016 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8017 wxPyEndAllowThreads(__tstate);
8018 if (PyErr_Occurred()) SWIG_fail;
8019 }
8020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8021 return resultobj;
8022 fail:
8023 return NULL;
8024 }
8025
8026
8027 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8028 PyObject *resultobj = 0;
8029 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8030 void *argp1 = 0 ;
8031 int res1 = 0 ;
8032 PyObject *swig_obj[1] ;
8033
8034 if (!args) SWIG_fail;
8035 swig_obj[0] = args;
8036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8037 if (!SWIG_IsOK(res1)) {
8038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8039 }
8040 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8041 {
8042 PyThreadState* __tstate = wxPyBeginAllowThreads();
8043 delete arg1;
8044
8045 wxPyEndAllowThreads(__tstate);
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 resultobj = SWIG_Py_Void();
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8056 PyObject *obj;
8057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8058 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8059 return SWIG_Py_Void();
8060 }
8061
8062 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8063 return SWIG_Python_InitShadowInstance(args);
8064 }
8065
8066 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8067 PyObject *resultobj = 0;
8068 bool result;
8069
8070 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8071 {
8072 PyThreadState* __tstate = wxPyBeginAllowThreads();
8073 result = (bool)wxThread_IsMain();
8074 wxPyEndAllowThreads(__tstate);
8075 if (PyErr_Occurred()) SWIG_fail;
8076 }
8077 {
8078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8079 }
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj = 0;
8088 wxString *arg1 = 0 ;
8089 wxToolTip *result = 0 ;
8090 bool temp1 = false ;
8091 PyObject * obj0 = 0 ;
8092 char * kwnames[] = {
8093 (char *) "tip", NULL
8094 };
8095
8096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8097 {
8098 arg1 = wxString_in_helper(obj0);
8099 if (arg1 == NULL) SWIG_fail;
8100 temp1 = true;
8101 }
8102 {
8103 if (!wxPyCheckForApp()) SWIG_fail;
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8110 {
8111 if (temp1)
8112 delete arg1;
8113 }
8114 return resultobj;
8115 fail:
8116 {
8117 if (temp1)
8118 delete arg1;
8119 }
8120 return NULL;
8121 }
8122
8123
8124 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8125 PyObject *resultobj = 0;
8126 wxToolTip *arg1 = (wxToolTip *) 0 ;
8127 void *argp1 = 0 ;
8128 int res1 = 0 ;
8129 PyObject *swig_obj[1] ;
8130
8131 if (!args) SWIG_fail;
8132 swig_obj[0] = args;
8133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8134 if (!SWIG_IsOK(res1)) {
8135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8136 }
8137 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8138 {
8139 PyThreadState* __tstate = wxPyBeginAllowThreads();
8140 delete arg1;
8141
8142 wxPyEndAllowThreads(__tstate);
8143 if (PyErr_Occurred()) SWIG_fail;
8144 }
8145 resultobj = SWIG_Py_Void();
8146 return resultobj;
8147 fail:
8148 return NULL;
8149 }
8150
8151
8152 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8153 PyObject *resultobj = 0;
8154 wxToolTip *arg1 = (wxToolTip *) 0 ;
8155 wxString *arg2 = 0 ;
8156 void *argp1 = 0 ;
8157 int res1 = 0 ;
8158 bool temp2 = false ;
8159 PyObject * obj0 = 0 ;
8160 PyObject * obj1 = 0 ;
8161 char * kwnames[] = {
8162 (char *) "self",(char *) "tip", NULL
8163 };
8164
8165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8167 if (!SWIG_IsOK(res1)) {
8168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8169 }
8170 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8171 {
8172 arg2 = wxString_in_helper(obj1);
8173 if (arg2 == NULL) SWIG_fail;
8174 temp2 = true;
8175 }
8176 {
8177 PyThreadState* __tstate = wxPyBeginAllowThreads();
8178 (arg1)->SetTip((wxString const &)*arg2);
8179 wxPyEndAllowThreads(__tstate);
8180 if (PyErr_Occurred()) SWIG_fail;
8181 }
8182 resultobj = SWIG_Py_Void();
8183 {
8184 if (temp2)
8185 delete arg2;
8186 }
8187 return resultobj;
8188 fail:
8189 {
8190 if (temp2)
8191 delete arg2;
8192 }
8193 return NULL;
8194 }
8195
8196
8197 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8198 PyObject *resultobj = 0;
8199 wxToolTip *arg1 = (wxToolTip *) 0 ;
8200 wxString result;
8201 void *argp1 = 0 ;
8202 int res1 = 0 ;
8203 PyObject *swig_obj[1] ;
8204
8205 if (!args) SWIG_fail;
8206 swig_obj[0] = args;
8207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8208 if (!SWIG_IsOK(res1)) {
8209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8210 }
8211 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8212 {
8213 PyThreadState* __tstate = wxPyBeginAllowThreads();
8214 result = (arg1)->GetTip();
8215 wxPyEndAllowThreads(__tstate);
8216 if (PyErr_Occurred()) SWIG_fail;
8217 }
8218 {
8219 #if wxUSE_UNICODE
8220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8221 #else
8222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8223 #endif
8224 }
8225 return resultobj;
8226 fail:
8227 return NULL;
8228 }
8229
8230
8231 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8232 PyObject *resultobj = 0;
8233 wxToolTip *arg1 = (wxToolTip *) 0 ;
8234 wxWindow *result = 0 ;
8235 void *argp1 = 0 ;
8236 int res1 = 0 ;
8237 PyObject *swig_obj[1] ;
8238
8239 if (!args) SWIG_fail;
8240 swig_obj[0] = args;
8241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8242 if (!SWIG_IsOK(res1)) {
8243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8244 }
8245 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 result = (wxWindow *)(arg1)->GetWindow();
8249 wxPyEndAllowThreads(__tstate);
8250 if (PyErr_Occurred()) SWIG_fail;
8251 }
8252 {
8253 resultobj = wxPyMake_wxObject(result, 0);
8254 }
8255 return resultobj;
8256 fail:
8257 return NULL;
8258 }
8259
8260
8261 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8262 PyObject *resultobj = 0;
8263 bool arg1 ;
8264 bool val1 ;
8265 int ecode1 = 0 ;
8266 PyObject * obj0 = 0 ;
8267 char * kwnames[] = {
8268 (char *) "flag", NULL
8269 };
8270
8271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8272 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8273 if (!SWIG_IsOK(ecode1)) {
8274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8275 }
8276 arg1 = static_cast< bool >(val1);
8277 {
8278 PyThreadState* __tstate = wxPyBeginAllowThreads();
8279 wxToolTip::Enable(arg1);
8280 wxPyEndAllowThreads(__tstate);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 resultobj = SWIG_Py_Void();
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj = 0;
8292 long arg1 ;
8293 long val1 ;
8294 int ecode1 = 0 ;
8295 PyObject * obj0 = 0 ;
8296 char * kwnames[] = {
8297 (char *) "milliseconds", NULL
8298 };
8299
8300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8301 ecode1 = SWIG_AsVal_long(obj0, &val1);
8302 if (!SWIG_IsOK(ecode1)) {
8303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8304 }
8305 arg1 = static_cast< long >(val1);
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 wxToolTip::SetDelay(arg1);
8309 wxPyEndAllowThreads(__tstate);
8310 if (PyErr_Occurred()) SWIG_fail;
8311 }
8312 resultobj = SWIG_Py_Void();
8313 return resultobj;
8314 fail:
8315 return NULL;
8316 }
8317
8318
8319 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8320 PyObject *obj;
8321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8322 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8323 return SWIG_Py_Void();
8324 }
8325
8326 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8327 return SWIG_Python_InitShadowInstance(args);
8328 }
8329
8330 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8331 PyObject *resultobj = 0;
8332 wxWindow *arg1 = (wxWindow *) 0 ;
8333 wxSize *arg2 = 0 ;
8334 wxCaret *result = 0 ;
8335 void *argp1 = 0 ;
8336 int res1 = 0 ;
8337 wxSize temp2 ;
8338 PyObject * obj0 = 0 ;
8339 PyObject * obj1 = 0 ;
8340 char * kwnames[] = {
8341 (char *) "window",(char *) "size", NULL
8342 };
8343
8344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8346 if (!SWIG_IsOK(res1)) {
8347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8348 }
8349 arg1 = reinterpret_cast< wxWindow * >(argp1);
8350 {
8351 arg2 = &temp2;
8352 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8353 }
8354 {
8355 if (!wxPyCheckForApp()) SWIG_fail;
8356 PyThreadState* __tstate = wxPyBeginAllowThreads();
8357 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8369 PyObject *resultobj = 0;
8370 wxCaret *arg1 = (wxCaret *) 0 ;
8371 void *argp1 = 0 ;
8372 int res1 = 0 ;
8373 PyObject *swig_obj[1] ;
8374
8375 if (!args) SWIG_fail;
8376 swig_obj[0] = args;
8377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8378 if (!SWIG_IsOK(res1)) {
8379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8380 }
8381 arg1 = reinterpret_cast< wxCaret * >(argp1);
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 delete arg1;
8385
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 resultobj = SWIG_Py_Void();
8390 return resultobj;
8391 fail:
8392 return NULL;
8393 }
8394
8395
8396 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8397 PyObject *resultobj = 0;
8398 wxCaret *arg1 = (wxCaret *) 0 ;
8399 void *argp1 = 0 ;
8400 int res1 = 0 ;
8401 PyObject *swig_obj[1] ;
8402
8403 if (!args) SWIG_fail;
8404 swig_obj[0] = args;
8405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8406 if (!SWIG_IsOK(res1)) {
8407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8408 }
8409 arg1 = reinterpret_cast< wxCaret * >(argp1);
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 wxCaret_Destroy(arg1);
8413 wxPyEndAllowThreads(__tstate);
8414 if (PyErr_Occurred()) SWIG_fail;
8415 }
8416 resultobj = SWIG_Py_Void();
8417 return resultobj;
8418 fail:
8419 return NULL;
8420 }
8421
8422
8423 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8424 PyObject *resultobj = 0;
8425 wxCaret *arg1 = (wxCaret *) 0 ;
8426 bool result;
8427 void *argp1 = 0 ;
8428 int res1 = 0 ;
8429 PyObject *swig_obj[1] ;
8430
8431 if (!args) SWIG_fail;
8432 swig_obj[0] = args;
8433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8434 if (!SWIG_IsOK(res1)) {
8435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8436 }
8437 arg1 = reinterpret_cast< wxCaret * >(argp1);
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (bool)(arg1)->IsOk();
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8446 }
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8454 PyObject *resultobj = 0;
8455 wxCaret *arg1 = (wxCaret *) 0 ;
8456 bool result;
8457 void *argp1 = 0 ;
8458 int res1 = 0 ;
8459 PyObject *swig_obj[1] ;
8460
8461 if (!args) SWIG_fail;
8462 swig_obj[0] = args;
8463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8464 if (!SWIG_IsOK(res1)) {
8465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8466 }
8467 arg1 = reinterpret_cast< wxCaret * >(argp1);
8468 {
8469 PyThreadState* __tstate = wxPyBeginAllowThreads();
8470 result = (bool)(arg1)->IsVisible();
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 {
8475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8476 }
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8484 PyObject *resultobj = 0;
8485 wxCaret *arg1 = (wxCaret *) 0 ;
8486 wxPoint result;
8487 void *argp1 = 0 ;
8488 int res1 = 0 ;
8489 PyObject *swig_obj[1] ;
8490
8491 if (!args) SWIG_fail;
8492 swig_obj[0] = args;
8493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8494 if (!SWIG_IsOK(res1)) {
8495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8496 }
8497 arg1 = reinterpret_cast< wxCaret * >(argp1);
8498 {
8499 PyThreadState* __tstate = wxPyBeginAllowThreads();
8500 result = (arg1)->GetPosition();
8501 wxPyEndAllowThreads(__tstate);
8502 if (PyErr_Occurred()) SWIG_fail;
8503 }
8504 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8505 return resultobj;
8506 fail:
8507 return NULL;
8508 }
8509
8510
8511 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8512 PyObject *resultobj = 0;
8513 wxCaret *arg1 = (wxCaret *) 0 ;
8514 int *arg2 = (int *) 0 ;
8515 int *arg3 = (int *) 0 ;
8516 void *argp1 = 0 ;
8517 int res1 = 0 ;
8518 int temp2 ;
8519 int res2 = SWIG_TMPOBJ ;
8520 int temp3 ;
8521 int res3 = SWIG_TMPOBJ ;
8522 PyObject *swig_obj[1] ;
8523
8524 arg2 = &temp2;
8525 arg3 = &temp3;
8526 if (!args) SWIG_fail;
8527 swig_obj[0] = args;
8528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8529 if (!SWIG_IsOK(res1)) {
8530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8531 }
8532 arg1 = reinterpret_cast< wxCaret * >(argp1);
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 (arg1)->GetPosition(arg2,arg3);
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_Py_Void();
8540 if (SWIG_IsTmpObj(res2)) {
8541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8542 } else {
8543 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8545 }
8546 if (SWIG_IsTmpObj(res3)) {
8547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8548 } else {
8549 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8551 }
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8559 PyObject *resultobj = 0;
8560 wxCaret *arg1 = (wxCaret *) 0 ;
8561 wxSize result;
8562 void *argp1 = 0 ;
8563 int res1 = 0 ;
8564 PyObject *swig_obj[1] ;
8565
8566 if (!args) SWIG_fail;
8567 swig_obj[0] = args;
8568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8569 if (!SWIG_IsOK(res1)) {
8570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8571 }
8572 arg1 = reinterpret_cast< wxCaret * >(argp1);
8573 {
8574 PyThreadState* __tstate = wxPyBeginAllowThreads();
8575 result = (arg1)->GetSize();
8576 wxPyEndAllowThreads(__tstate);
8577 if (PyErr_Occurred()) SWIG_fail;
8578 }
8579 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8580 return resultobj;
8581 fail:
8582 return NULL;
8583 }
8584
8585
8586 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8587 PyObject *resultobj = 0;
8588 wxCaret *arg1 = (wxCaret *) 0 ;
8589 int *arg2 = (int *) 0 ;
8590 int *arg3 = (int *) 0 ;
8591 void *argp1 = 0 ;
8592 int res1 = 0 ;
8593 int temp2 ;
8594 int res2 = SWIG_TMPOBJ ;
8595 int temp3 ;
8596 int res3 = SWIG_TMPOBJ ;
8597 PyObject *swig_obj[1] ;
8598
8599 arg2 = &temp2;
8600 arg3 = &temp3;
8601 if (!args) SWIG_fail;
8602 swig_obj[0] = args;
8603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8604 if (!SWIG_IsOK(res1)) {
8605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8606 }
8607 arg1 = reinterpret_cast< wxCaret * >(argp1);
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 (arg1)->GetSize(arg2,arg3);
8611 wxPyEndAllowThreads(__tstate);
8612 if (PyErr_Occurred()) SWIG_fail;
8613 }
8614 resultobj = SWIG_Py_Void();
8615 if (SWIG_IsTmpObj(res2)) {
8616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8617 } else {
8618 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8620 }
8621 if (SWIG_IsTmpObj(res3)) {
8622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8623 } else {
8624 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8626 }
8627 return resultobj;
8628 fail:
8629 return NULL;
8630 }
8631
8632
8633 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8634 PyObject *resultobj = 0;
8635 wxCaret *arg1 = (wxCaret *) 0 ;
8636 wxWindow *result = 0 ;
8637 void *argp1 = 0 ;
8638 int res1 = 0 ;
8639 PyObject *swig_obj[1] ;
8640
8641 if (!args) SWIG_fail;
8642 swig_obj[0] = args;
8643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8644 if (!SWIG_IsOK(res1)) {
8645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8646 }
8647 arg1 = reinterpret_cast< wxCaret * >(argp1);
8648 {
8649 PyThreadState* __tstate = wxPyBeginAllowThreads();
8650 result = (wxWindow *)(arg1)->GetWindow();
8651 wxPyEndAllowThreads(__tstate);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 {
8655 resultobj = wxPyMake_wxObject(result, 0);
8656 }
8657 return resultobj;
8658 fail:
8659 return NULL;
8660 }
8661
8662
8663 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8664 PyObject *resultobj = 0;
8665 wxCaret *arg1 = (wxCaret *) 0 ;
8666 int arg2 ;
8667 int arg3 ;
8668 void *argp1 = 0 ;
8669 int res1 = 0 ;
8670 int val2 ;
8671 int ecode2 = 0 ;
8672 int val3 ;
8673 int ecode3 = 0 ;
8674 PyObject * obj0 = 0 ;
8675 PyObject * obj1 = 0 ;
8676 PyObject * obj2 = 0 ;
8677 char * kwnames[] = {
8678 (char *) "self",(char *) "x",(char *) "y", NULL
8679 };
8680
8681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8683 if (!SWIG_IsOK(res1)) {
8684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8685 }
8686 arg1 = reinterpret_cast< wxCaret * >(argp1);
8687 ecode2 = SWIG_AsVal_int(obj1, &val2);
8688 if (!SWIG_IsOK(ecode2)) {
8689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8690 }
8691 arg2 = static_cast< int >(val2);
8692 ecode3 = SWIG_AsVal_int(obj2, &val3);
8693 if (!SWIG_IsOK(ecode3)) {
8694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8695 }
8696 arg3 = static_cast< int >(val3);
8697 {
8698 PyThreadState* __tstate = wxPyBeginAllowThreads();
8699 (arg1)->Move(arg2,arg3);
8700 wxPyEndAllowThreads(__tstate);
8701 if (PyErr_Occurred()) SWIG_fail;
8702 }
8703 resultobj = SWIG_Py_Void();
8704 return resultobj;
8705 fail:
8706 return NULL;
8707 }
8708
8709
8710 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8711 PyObject *resultobj = 0;
8712 wxCaret *arg1 = (wxCaret *) 0 ;
8713 wxPoint *arg2 = 0 ;
8714 void *argp1 = 0 ;
8715 int res1 = 0 ;
8716 wxPoint temp2 ;
8717 PyObject * obj0 = 0 ;
8718 PyObject * obj1 = 0 ;
8719 char * kwnames[] = {
8720 (char *) "self",(char *) "pt", NULL
8721 };
8722
8723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8727 }
8728 arg1 = reinterpret_cast< wxCaret * >(argp1);
8729 {
8730 arg2 = &temp2;
8731 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8732 }
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 (arg1)->Move((wxPoint const &)*arg2);
8736 wxPyEndAllowThreads(__tstate);
8737 if (PyErr_Occurred()) SWIG_fail;
8738 }
8739 resultobj = SWIG_Py_Void();
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj = 0;
8748 wxCaret *arg1 = (wxCaret *) 0 ;
8749 int arg2 ;
8750 int arg3 ;
8751 void *argp1 = 0 ;
8752 int res1 = 0 ;
8753 int val2 ;
8754 int ecode2 = 0 ;
8755 int val3 ;
8756 int ecode3 = 0 ;
8757 PyObject * obj0 = 0 ;
8758 PyObject * obj1 = 0 ;
8759 PyObject * obj2 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "width",(char *) "height", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8768 }
8769 arg1 = reinterpret_cast< wxCaret * >(argp1);
8770 ecode2 = SWIG_AsVal_int(obj1, &val2);
8771 if (!SWIG_IsOK(ecode2)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8773 }
8774 arg2 = static_cast< int >(val2);
8775 ecode3 = SWIG_AsVal_int(obj2, &val3);
8776 if (!SWIG_IsOK(ecode3)) {
8777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8778 }
8779 arg3 = static_cast< int >(val3);
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 (arg1)->SetSize(arg2,arg3);
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_Py_Void();
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj = 0;
8795 wxCaret *arg1 = (wxCaret *) 0 ;
8796 wxSize *arg2 = 0 ;
8797 void *argp1 = 0 ;
8798 int res1 = 0 ;
8799 wxSize temp2 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "size", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8810 }
8811 arg1 = reinterpret_cast< wxCaret * >(argp1);
8812 {
8813 arg2 = &temp2;
8814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8815 }
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 (arg1)->SetSize((wxSize const &)*arg2);
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj = 0;
8831 wxCaret *arg1 = (wxCaret *) 0 ;
8832 int arg2 = (int) true ;
8833 void *argp1 = 0 ;
8834 int res1 = 0 ;
8835 int val2 ;
8836 int ecode2 = 0 ;
8837 PyObject * obj0 = 0 ;
8838 PyObject * obj1 = 0 ;
8839 char * kwnames[] = {
8840 (char *) "self",(char *) "show", NULL
8841 };
8842
8843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8845 if (!SWIG_IsOK(res1)) {
8846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8847 }
8848 arg1 = reinterpret_cast< wxCaret * >(argp1);
8849 if (obj1) {
8850 ecode2 = SWIG_AsVal_int(obj1, &val2);
8851 if (!SWIG_IsOK(ecode2)) {
8852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8853 }
8854 arg2 = static_cast< int >(val2);
8855 }
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 (arg1)->Show(arg2);
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = SWIG_Py_Void();
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8870 PyObject *resultobj = 0;
8871 wxCaret *arg1 = (wxCaret *) 0 ;
8872 void *argp1 = 0 ;
8873 int res1 = 0 ;
8874 PyObject *swig_obj[1] ;
8875
8876 if (!args) SWIG_fail;
8877 swig_obj[0] = args;
8878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8879 if (!SWIG_IsOK(res1)) {
8880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8881 }
8882 arg1 = reinterpret_cast< wxCaret * >(argp1);
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 (arg1)->Hide();
8886 wxPyEndAllowThreads(__tstate);
8887 if (PyErr_Occurred()) SWIG_fail;
8888 }
8889 resultobj = SWIG_Py_Void();
8890 return resultobj;
8891 fail:
8892 return NULL;
8893 }
8894
8895
8896 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8897 PyObject *resultobj = 0;
8898 int result;
8899
8900 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8901 {
8902 PyThreadState* __tstate = wxPyBeginAllowThreads();
8903 result = (int)wxCaret::GetBlinkTime();
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 resultobj = SWIG_From_int(static_cast< int >(result));
8908 return resultobj;
8909 fail:
8910 return NULL;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj = 0;
8916 int arg1 ;
8917 int val1 ;
8918 int ecode1 = 0 ;
8919 PyObject * obj0 = 0 ;
8920 char * kwnames[] = {
8921 (char *) "milliseconds", NULL
8922 };
8923
8924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8925 ecode1 = SWIG_AsVal_int(obj0, &val1);
8926 if (!SWIG_IsOK(ecode1)) {
8927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8928 }
8929 arg1 = static_cast< int >(val1);
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 wxCaret::SetBlinkTime(arg1);
8933 wxPyEndAllowThreads(__tstate);
8934 if (PyErr_Occurred()) SWIG_fail;
8935 }
8936 resultobj = SWIG_Py_Void();
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8944 PyObject *obj;
8945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8946 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8947 return SWIG_Py_Void();
8948 }
8949
8950 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951 return SWIG_Python_InitShadowInstance(args);
8952 }
8953
8954 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj = 0;
8956 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8957 wxBusyCursor *result = 0 ;
8958 void *argp1 = 0 ;
8959 int res1 = 0 ;
8960 PyObject * obj0 = 0 ;
8961 char * kwnames[] = {
8962 (char *) "cursor", NULL
8963 };
8964
8965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8966 if (obj0) {
8967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8970 }
8971 arg1 = reinterpret_cast< wxCursor * >(argp1);
8972 }
8973 {
8974 if (!wxPyCheckForApp()) SWIG_fail;
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8988 PyObject *resultobj = 0;
8989 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject *swig_obj[1] ;
8993
8994 if (!args) SWIG_fail;
8995 swig_obj[0] = args;
8996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8997 if (!SWIG_IsOK(res1)) {
8998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8999 }
9000 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 delete arg1;
9004
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 resultobj = SWIG_Py_Void();
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9016 PyObject *obj;
9017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9018 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9019 return SWIG_Py_Void();
9020 }
9021
9022 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 return SWIG_Python_InitShadowInstance(args);
9024 }
9025
9026 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9027 PyObject *resultobj = 0;
9028 wxWindow *arg1 = (wxWindow *) NULL ;
9029 wxWindowDisabler *result = 0 ;
9030 void *argp1 = 0 ;
9031 int res1 = 0 ;
9032 PyObject * obj0 = 0 ;
9033 char * kwnames[] = {
9034 (char *) "winToSkip", NULL
9035 };
9036
9037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9038 if (obj0) {
9039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9040 if (!SWIG_IsOK(res1)) {
9041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9042 }
9043 arg1 = reinterpret_cast< wxWindow * >(argp1);
9044 }
9045 {
9046 if (!wxPyCheckForApp()) SWIG_fail;
9047 PyThreadState* __tstate = wxPyBeginAllowThreads();
9048 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9049 wxPyEndAllowThreads(__tstate);
9050 if (PyErr_Occurred()) SWIG_fail;
9051 }
9052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9053 return resultobj;
9054 fail:
9055 return NULL;
9056 }
9057
9058
9059 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9060 PyObject *resultobj = 0;
9061 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9062 void *argp1 = 0 ;
9063 int res1 = 0 ;
9064 PyObject *swig_obj[1] ;
9065
9066 if (!args) SWIG_fail;
9067 swig_obj[0] = args;
9068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9069 if (!SWIG_IsOK(res1)) {
9070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9071 }
9072 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 delete arg1;
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_Py_Void();
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *obj;
9089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9090 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9091 return SWIG_Py_Void();
9092 }
9093
9094 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 return SWIG_Python_InitShadowInstance(args);
9096 }
9097
9098 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9099 PyObject *resultobj = 0;
9100 wxString *arg1 = 0 ;
9101 wxBusyInfo *result = 0 ;
9102 bool temp1 = false ;
9103 PyObject * obj0 = 0 ;
9104 char * kwnames[] = {
9105 (char *) "message", NULL
9106 };
9107
9108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9109 {
9110 arg1 = wxString_in_helper(obj0);
9111 if (arg1 == NULL) SWIG_fail;
9112 temp1 = true;
9113 }
9114 {
9115 if (!wxPyCheckForApp()) SWIG_fail;
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9118 wxPyEndAllowThreads(__tstate);
9119 if (PyErr_Occurred()) SWIG_fail;
9120 }
9121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9122 {
9123 if (temp1)
9124 delete arg1;
9125 }
9126 return resultobj;
9127 fail:
9128 {
9129 if (temp1)
9130 delete arg1;
9131 }
9132 return NULL;
9133 }
9134
9135
9136 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9137 PyObject *resultobj = 0;
9138 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9139 void *argp1 = 0 ;
9140 int res1 = 0 ;
9141 PyObject *swig_obj[1] ;
9142
9143 if (!args) SWIG_fail;
9144 swig_obj[0] = args;
9145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9146 if (!SWIG_IsOK(res1)) {
9147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9148 }
9149 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9150 {
9151 PyThreadState* __tstate = wxPyBeginAllowThreads();
9152 delete arg1;
9153
9154 wxPyEndAllowThreads(__tstate);
9155 if (PyErr_Occurred()) SWIG_fail;
9156 }
9157 resultobj = SWIG_Py_Void();
9158 return resultobj;
9159 fail:
9160 return NULL;
9161 }
9162
9163
9164 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9165 PyObject *obj;
9166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9167 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9168 return SWIG_Py_Void();
9169 }
9170
9171 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9172 return SWIG_Python_InitShadowInstance(args);
9173 }
9174
9175 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9176 PyObject *resultobj = 0;
9177 wxStopWatch *result = 0 ;
9178
9179 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 result = (wxStopWatch *)new wxStopWatch();
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9187 return resultobj;
9188 fail:
9189 return NULL;
9190 }
9191
9192
9193 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9194 PyObject *resultobj = 0;
9195 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9196 long arg2 = (long) 0 ;
9197 void *argp1 = 0 ;
9198 int res1 = 0 ;
9199 long val2 ;
9200 int ecode2 = 0 ;
9201 PyObject * obj0 = 0 ;
9202 PyObject * obj1 = 0 ;
9203 char * kwnames[] = {
9204 (char *) "self",(char *) "t0", NULL
9205 };
9206
9207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9209 if (!SWIG_IsOK(res1)) {
9210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9211 }
9212 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9213 if (obj1) {
9214 ecode2 = SWIG_AsVal_long(obj1, &val2);
9215 if (!SWIG_IsOK(ecode2)) {
9216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9217 }
9218 arg2 = static_cast< long >(val2);
9219 }
9220 {
9221 PyThreadState* __tstate = wxPyBeginAllowThreads();
9222 (arg1)->Start(arg2);
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 resultobj = SWIG_Py_Void();
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234 PyObject *resultobj = 0;
9235 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9236 void *argp1 = 0 ;
9237 int res1 = 0 ;
9238 PyObject *swig_obj[1] ;
9239
9240 if (!args) SWIG_fail;
9241 swig_obj[0] = args;
9242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9245 }
9246 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 (arg1)->Pause();
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 resultobj = SWIG_Py_Void();
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9261 PyObject *resultobj = 0;
9262 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9263 void *argp1 = 0 ;
9264 int res1 = 0 ;
9265 PyObject *swig_obj[1] ;
9266
9267 if (!args) SWIG_fail;
9268 swig_obj[0] = args;
9269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9270 if (!SWIG_IsOK(res1)) {
9271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9272 }
9273 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9274 {
9275 PyThreadState* __tstate = wxPyBeginAllowThreads();
9276 (arg1)->Resume();
9277 wxPyEndAllowThreads(__tstate);
9278 if (PyErr_Occurred()) SWIG_fail;
9279 }
9280 resultobj = SWIG_Py_Void();
9281 return resultobj;
9282 fail:
9283 return NULL;
9284 }
9285
9286
9287 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9288 PyObject *resultobj = 0;
9289 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9290 long result;
9291 void *argp1 = 0 ;
9292 int res1 = 0 ;
9293 PyObject *swig_obj[1] ;
9294
9295 if (!args) SWIG_fail;
9296 swig_obj[0] = args;
9297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9298 if (!SWIG_IsOK(res1)) {
9299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9300 }
9301 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9302 {
9303 PyThreadState* __tstate = wxPyBeginAllowThreads();
9304 result = (long)((wxStopWatch const *)arg1)->Time();
9305 wxPyEndAllowThreads(__tstate);
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 resultobj = SWIG_From_long(static_cast< long >(result));
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9316 PyObject *obj;
9317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9318 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9319 return SWIG_Py_Void();
9320 }
9321
9322 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9323 return SWIG_Python_InitShadowInstance(args);
9324 }
9325
9326 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9327 PyObject *resultobj = 0;
9328 int arg1 = (int) 9 ;
9329 int arg2 = (int) wxID_FILE1 ;
9330 wxFileHistory *result = 0 ;
9331 int val1 ;
9332 int ecode1 = 0 ;
9333 int val2 ;
9334 int ecode2 = 0 ;
9335 PyObject * obj0 = 0 ;
9336 PyObject * obj1 = 0 ;
9337 char * kwnames[] = {
9338 (char *) "maxFiles",(char *) "idBase", NULL
9339 };
9340
9341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9342 if (obj0) {
9343 ecode1 = SWIG_AsVal_int(obj0, &val1);
9344 if (!SWIG_IsOK(ecode1)) {
9345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9346 }
9347 arg1 = static_cast< int >(val1);
9348 }
9349 if (obj1) {
9350 ecode2 = SWIG_AsVal_int(obj1, &val2);
9351 if (!SWIG_IsOK(ecode2)) {
9352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9353 }
9354 arg2 = static_cast< int >(val2);
9355 }
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9370 PyObject *resultobj = 0;
9371 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9372 void *argp1 = 0 ;
9373 int res1 = 0 ;
9374 PyObject *swig_obj[1] ;
9375
9376 if (!args) SWIG_fail;
9377 swig_obj[0] = args;
9378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9379 if (!SWIG_IsOK(res1)) {
9380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9381 }
9382 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 delete arg1;
9386
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 resultobj = SWIG_Py_Void();
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj = 0;
9399 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9400 wxString *arg2 = 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 bool temp2 = false ;
9404 PyObject * obj0 = 0 ;
9405 PyObject * obj1 = 0 ;
9406 char * kwnames[] = {
9407 (char *) "self",(char *) "file", NULL
9408 };
9409
9410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9412 if (!SWIG_IsOK(res1)) {
9413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9414 }
9415 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9416 {
9417 arg2 = wxString_in_helper(obj1);
9418 if (arg2 == NULL) SWIG_fail;
9419 temp2 = true;
9420 }
9421 {
9422 PyThreadState* __tstate = wxPyBeginAllowThreads();
9423 (arg1)->AddFileToHistory((wxString const &)*arg2);
9424 wxPyEndAllowThreads(__tstate);
9425 if (PyErr_Occurred()) SWIG_fail;
9426 }
9427 resultobj = SWIG_Py_Void();
9428 {
9429 if (temp2)
9430 delete arg2;
9431 }
9432 return resultobj;
9433 fail:
9434 {
9435 if (temp2)
9436 delete arg2;
9437 }
9438 return NULL;
9439 }
9440
9441
9442 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9443 PyObject *resultobj = 0;
9444 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9445 int arg2 ;
9446 void *argp1 = 0 ;
9447 int res1 = 0 ;
9448 int val2 ;
9449 int ecode2 = 0 ;
9450 PyObject * obj0 = 0 ;
9451 PyObject * obj1 = 0 ;
9452 char * kwnames[] = {
9453 (char *) "self",(char *) "i", NULL
9454 };
9455
9456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9460 }
9461 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9462 ecode2 = SWIG_AsVal_int(obj1, &val2);
9463 if (!SWIG_IsOK(ecode2)) {
9464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9465 }
9466 arg2 = static_cast< int >(val2);
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 (arg1)->RemoveFileFromHistory(arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_Py_Void();
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *resultobj = 0;
9482 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9483 int result;
9484 void *argp1 = 0 ;
9485 int res1 = 0 ;
9486 PyObject *swig_obj[1] ;
9487
9488 if (!args) SWIG_fail;
9489 swig_obj[0] = args;
9490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9493 }
9494 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 resultobj = SWIG_From_int(static_cast< int >(result));
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj = 0;
9510 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9511 wxMenu *arg2 = (wxMenu *) 0 ;
9512 void *argp1 = 0 ;
9513 int res1 = 0 ;
9514 void *argp2 = 0 ;
9515 int res2 = 0 ;
9516 PyObject * obj0 = 0 ;
9517 PyObject * obj1 = 0 ;
9518 char * kwnames[] = {
9519 (char *) "self",(char *) "menu", NULL
9520 };
9521
9522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9524 if (!SWIG_IsOK(res1)) {
9525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9526 }
9527 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9528 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9529 if (!SWIG_IsOK(res2)) {
9530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9531 }
9532 arg2 = reinterpret_cast< wxMenu * >(argp2);
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 (arg1)->UseMenu(arg2);
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 resultobj = SWIG_Py_Void();
9540 return resultobj;
9541 fail:
9542 return NULL;
9543 }
9544
9545
9546 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9547 PyObject *resultobj = 0;
9548 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9549 wxMenu *arg2 = (wxMenu *) 0 ;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 void *argp2 = 0 ;
9553 int res2 = 0 ;
9554 PyObject * obj0 = 0 ;
9555 PyObject * obj1 = 0 ;
9556 char * kwnames[] = {
9557 (char *) "self",(char *) "menu", NULL
9558 };
9559
9560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9562 if (!SWIG_IsOK(res1)) {
9563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9564 }
9565 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9567 if (!SWIG_IsOK(res2)) {
9568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9569 }
9570 arg2 = reinterpret_cast< wxMenu * >(argp2);
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 (arg1)->RemoveMenu(arg2);
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 resultobj = SWIG_Py_Void();
9578 return resultobj;
9579 fail:
9580 return NULL;
9581 }
9582
9583
9584 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9585 PyObject *resultobj = 0;
9586 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9587 wxConfigBase *arg2 = 0 ;
9588 void *argp1 = 0 ;
9589 int res1 = 0 ;
9590 void *argp2 = 0 ;
9591 int res2 = 0 ;
9592 PyObject * obj0 = 0 ;
9593 PyObject * obj1 = 0 ;
9594 char * kwnames[] = {
9595 (char *) "self",(char *) "config", NULL
9596 };
9597
9598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9600 if (!SWIG_IsOK(res1)) {
9601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9602 }
9603 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9605 if (!SWIG_IsOK(res2)) {
9606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9607 }
9608 if (!argp2) {
9609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9610 }
9611 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 (arg1)->Load(*arg2);
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 resultobj = SWIG_Py_Void();
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj = 0;
9627 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9628 wxConfigBase *arg2 = 0 ;
9629 void *argp1 = 0 ;
9630 int res1 = 0 ;
9631 void *argp2 = 0 ;
9632 int res2 = 0 ;
9633 PyObject * obj0 = 0 ;
9634 PyObject * obj1 = 0 ;
9635 char * kwnames[] = {
9636 (char *) "self",(char *) "config", NULL
9637 };
9638
9639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9641 if (!SWIG_IsOK(res1)) {
9642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9643 }
9644 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9645 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9646 if (!SWIG_IsOK(res2)) {
9647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9648 }
9649 if (!argp2) {
9650 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9651 }
9652 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 (arg1)->Save(*arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 PyObject *swig_obj[1] ;
9672
9673 if (!args) SWIG_fail;
9674 swig_obj[0] = args;
9675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9678 }
9679 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 (arg1)->AddFilesToMenu();
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 resultobj = SWIG_Py_Void();
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9694 PyObject *resultobj = 0;
9695 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9696 wxMenu *arg2 = (wxMenu *) 0 ;
9697 void *argp1 = 0 ;
9698 int res1 = 0 ;
9699 void *argp2 = 0 ;
9700 int res2 = 0 ;
9701 PyObject * obj0 = 0 ;
9702 PyObject * obj1 = 0 ;
9703 char * kwnames[] = {
9704 (char *) "self",(char *) "menu", NULL
9705 };
9706
9707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9709 if (!SWIG_IsOK(res1)) {
9710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9711 }
9712 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9714 if (!SWIG_IsOK(res2)) {
9715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9716 }
9717 arg2 = reinterpret_cast< wxMenu * >(argp2);
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 (arg1)->AddFilesToMenu(arg2);
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 resultobj = SWIG_Py_Void();
9725 return resultobj;
9726 fail:
9727 return NULL;
9728 }
9729
9730
9731 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj = 0;
9733 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9734 int arg2 ;
9735 wxString result;
9736 void *argp1 = 0 ;
9737 int res1 = 0 ;
9738 int val2 ;
9739 int ecode2 = 0 ;
9740 PyObject * obj0 = 0 ;
9741 PyObject * obj1 = 0 ;
9742 char * kwnames[] = {
9743 (char *) "self",(char *) "i", NULL
9744 };
9745
9746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9748 if (!SWIG_IsOK(res1)) {
9749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9750 }
9751 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9752 ecode2 = SWIG_AsVal_int(obj1, &val2);
9753 if (!SWIG_IsOK(ecode2)) {
9754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9755 }
9756 arg2 = static_cast< int >(val2);
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 {
9764 #if wxUSE_UNICODE
9765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9766 #else
9767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9768 #endif
9769 }
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9777 PyObject *resultobj = 0;
9778 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9779 int result;
9780 void *argp1 = 0 ;
9781 int res1 = 0 ;
9782 PyObject *swig_obj[1] ;
9783
9784 if (!args) SWIG_fail;
9785 swig_obj[0] = args;
9786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9789 }
9790 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 result = (int)((wxFileHistory const *)arg1)->GetCount();
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 resultobj = SWIG_From_int(static_cast< int >(result));
9798 return resultobj;
9799 fail:
9800 return NULL;
9801 }
9802
9803
9804 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9805 PyObject *obj;
9806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9807 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9808 return SWIG_Py_Void();
9809 }
9810
9811 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9812 return SWIG_Python_InitShadowInstance(args);
9813 }
9814
9815 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj = 0;
9817 wxString *arg1 = 0 ;
9818 wxString const &arg2_defvalue = wxPyEmptyString ;
9819 wxString *arg2 = (wxString *) &arg2_defvalue ;
9820 wxSingleInstanceChecker *result = 0 ;
9821 bool temp1 = false ;
9822 bool temp2 = false ;
9823 PyObject * obj0 = 0 ;
9824 PyObject * obj1 = 0 ;
9825 char * kwnames[] = {
9826 (char *) "name",(char *) "path", NULL
9827 };
9828
9829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9830 {
9831 arg1 = wxString_in_helper(obj0);
9832 if (arg1 == NULL) SWIG_fail;
9833 temp1 = true;
9834 }
9835 if (obj1) {
9836 {
9837 arg2 = wxString_in_helper(obj1);
9838 if (arg2 == NULL) SWIG_fail;
9839 temp2 = true;
9840 }
9841 }
9842 {
9843 PyThreadState* __tstate = wxPyBeginAllowThreads();
9844 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9849 {
9850 if (temp1)
9851 delete arg1;
9852 }
9853 {
9854 if (temp2)
9855 delete arg2;
9856 }
9857 return resultobj;
9858 fail:
9859 {
9860 if (temp1)
9861 delete arg1;
9862 }
9863 {
9864 if (temp2)
9865 delete arg2;
9866 }
9867 return NULL;
9868 }
9869
9870
9871 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9872 PyObject *resultobj = 0;
9873 wxSingleInstanceChecker *result = 0 ;
9874
9875 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9883 return resultobj;
9884 fail:
9885 return NULL;
9886 }
9887
9888
9889 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 PyObject *resultobj = 0;
9891 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9892 void *argp1 = 0 ;
9893 int res1 = 0 ;
9894 PyObject *swig_obj[1] ;
9895
9896 if (!args) SWIG_fail;
9897 swig_obj[0] = args;
9898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9899 if (!SWIG_IsOK(res1)) {
9900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9901 }
9902 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 delete arg1;
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_Py_Void();
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9918 PyObject *resultobj = 0;
9919 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9920 wxString *arg2 = 0 ;
9921 wxString const &arg3_defvalue = wxPyEmptyString ;
9922 wxString *arg3 = (wxString *) &arg3_defvalue ;
9923 bool result;
9924 void *argp1 = 0 ;
9925 int res1 = 0 ;
9926 bool temp2 = false ;
9927 bool temp3 = false ;
9928 PyObject * obj0 = 0 ;
9929 PyObject * obj1 = 0 ;
9930 PyObject * obj2 = 0 ;
9931 char * kwnames[] = {
9932 (char *) "self",(char *) "name",(char *) "path", NULL
9933 };
9934
9935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9937 if (!SWIG_IsOK(res1)) {
9938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9939 }
9940 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9941 {
9942 arg2 = wxString_in_helper(obj1);
9943 if (arg2 == NULL) SWIG_fail;
9944 temp2 = true;
9945 }
9946 if (obj2) {
9947 {
9948 arg3 = wxString_in_helper(obj2);
9949 if (arg3 == NULL) SWIG_fail;
9950 temp3 = true;
9951 }
9952 }
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 {
9960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9961 }
9962 {
9963 if (temp2)
9964 delete arg2;
9965 }
9966 {
9967 if (temp3)
9968 delete arg3;
9969 }
9970 return resultobj;
9971 fail:
9972 {
9973 if (temp2)
9974 delete arg2;
9975 }
9976 {
9977 if (temp3)
9978 delete arg3;
9979 }
9980 return NULL;
9981 }
9982
9983
9984 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9985 PyObject *resultobj = 0;
9986 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9987 bool result;
9988 void *argp1 = 0 ;
9989 int res1 = 0 ;
9990 PyObject *swig_obj[1] ;
9991
9992 if (!args) SWIG_fail;
9993 swig_obj[0] = args;
9994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9995 if (!SWIG_IsOK(res1)) {
9996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9997 }
9998 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10002 wxPyEndAllowThreads(__tstate);
10003 if (PyErr_Occurred()) SWIG_fail;
10004 }
10005 {
10006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10007 }
10008 return resultobj;
10009 fail:
10010 return NULL;
10011 }
10012
10013
10014 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10015 PyObject *obj;
10016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10017 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10018 return SWIG_Py_Void();
10019 }
10020
10021 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10022 return SWIG_Python_InitShadowInstance(args);
10023 }
10024
10025 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10026 PyObject *resultobj = 0;
10027 wxWindow *arg1 = (wxWindow *) 0 ;
10028 wxDC *arg2 = 0 ;
10029 bool result;
10030 void *argp1 = 0 ;
10031 int res1 = 0 ;
10032 void *argp2 = 0 ;
10033 int res2 = 0 ;
10034 PyObject * obj0 = 0 ;
10035 PyObject * obj1 = 0 ;
10036 char * kwnames[] = {
10037 (char *) "window",(char *) "dc", NULL
10038 };
10039
10040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10042 if (!SWIG_IsOK(res1)) {
10043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10044 }
10045 arg1 = reinterpret_cast< wxWindow * >(argp1);
10046 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10047 if (!SWIG_IsOK(res2)) {
10048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10049 }
10050 if (!argp2) {
10051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10052 }
10053 arg2 = reinterpret_cast< wxDC * >(argp2);
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 {
10061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10062 }
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10070 PyObject *resultobj = 0;
10071 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 PyObject *swig_obj[1] ;
10075
10076 if (!args) SWIG_fail;
10077 swig_obj[0] = args;
10078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10079 if (!SWIG_IsOK(res1)) {
10080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10081 }
10082 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 delete arg1;
10086
10087 wxPyEndAllowThreads(__tstate);
10088 if (PyErr_Occurred()) SWIG_fail;
10089 }
10090 resultobj = SWIG_Py_Void();
10091 return resultobj;
10092 fail:
10093 return NULL;
10094 }
10095
10096
10097 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10098 PyObject *resultobj = 0;
10099 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10100 wxString result;
10101 void *argp1 = 0 ;
10102 int res1 = 0 ;
10103 PyObject *swig_obj[1] ;
10104
10105 if (!args) SWIG_fail;
10106 swig_obj[0] = args;
10107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10108 if (!SWIG_IsOK(res1)) {
10109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10110 }
10111 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 result = (arg1)->GetTip();
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 {
10119 #if wxUSE_UNICODE
10120 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10121 #else
10122 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10123 #endif
10124 }
10125 return resultobj;
10126 fail:
10127 return NULL;
10128 }
10129
10130
10131 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10132 PyObject *resultobj = 0;
10133 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10134 size_t result;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 PyObject *swig_obj[1] ;
10138
10139 if (!args) SWIG_fail;
10140 swig_obj[0] = args;
10141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10142 if (!SWIG_IsOK(res1)) {
10143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10144 }
10145 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10146 {
10147 PyThreadState* __tstate = wxPyBeginAllowThreads();
10148 result = (size_t)(arg1)->GetCurrentTip();
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10153 return resultobj;
10154 fail:
10155 return NULL;
10156 }
10157
10158
10159 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10160 PyObject *resultobj = 0;
10161 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10162 wxString *arg2 = 0 ;
10163 wxString result;
10164 void *argp1 = 0 ;
10165 int res1 = 0 ;
10166 bool temp2 = false ;
10167 PyObject * obj0 = 0 ;
10168 PyObject * obj1 = 0 ;
10169 char * kwnames[] = {
10170 (char *) "self",(char *) "tip", NULL
10171 };
10172
10173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10175 if (!SWIG_IsOK(res1)) {
10176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10177 }
10178 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10179 {
10180 arg2 = wxString_in_helper(obj1);
10181 if (arg2 == NULL) SWIG_fail;
10182 temp2 = true;
10183 }
10184 {
10185 PyThreadState* __tstate = wxPyBeginAllowThreads();
10186 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10187 wxPyEndAllowThreads(__tstate);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 {
10191 #if wxUSE_UNICODE
10192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10193 #else
10194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10195 #endif
10196 }
10197 {
10198 if (temp2)
10199 delete arg2;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp2)
10205 delete arg2;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10212 PyObject *obj;
10213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10214 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10215 return SWIG_Py_Void();
10216 }
10217
10218 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj = 0;
10220 size_t arg1 ;
10221 wxPyTipProvider *result = 0 ;
10222 size_t val1 ;
10223 int ecode1 = 0 ;
10224 PyObject * obj0 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "currentTip", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10230 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10231 if (!SWIG_IsOK(ecode1)) {
10232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10233 }
10234 arg1 = static_cast< size_t >(val1);
10235 {
10236 PyThreadState* __tstate = wxPyBeginAllowThreads();
10237 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj = 0;
10250 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10251 PyObject *arg2 = (PyObject *) 0 ;
10252 PyObject *arg3 = (PyObject *) 0 ;
10253 void *argp1 = 0 ;
10254 int res1 = 0 ;
10255 PyObject * obj0 = 0 ;
10256 PyObject * obj1 = 0 ;
10257 PyObject * obj2 = 0 ;
10258 char * kwnames[] = {
10259 (char *) "self",(char *) "self",(char *) "_class", NULL
10260 };
10261
10262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10264 if (!SWIG_IsOK(res1)) {
10265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10266 }
10267 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10268 arg2 = obj1;
10269 arg3 = obj2;
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 (arg1)->_setCallbackInfo(arg2,arg3);
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 resultobj = SWIG_Py_Void();
10277 return resultobj;
10278 fail:
10279 return NULL;
10280 }
10281
10282
10283 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10284 PyObject *obj;
10285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10286 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10287 return SWIG_Py_Void();
10288 }
10289
10290 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10291 return SWIG_Python_InitShadowInstance(args);
10292 }
10293
10294 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10295 PyObject *resultobj = 0;
10296 wxWindow *arg1 = (wxWindow *) 0 ;
10297 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10298 bool arg3 = (bool) true ;
10299 bool result;
10300 void *argp1 = 0 ;
10301 int res1 = 0 ;
10302 void *argp2 = 0 ;
10303 int res2 = 0 ;
10304 bool val3 ;
10305 int ecode3 = 0 ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 PyObject * obj2 = 0 ;
10309 char * kwnames[] = {
10310 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10311 };
10312
10313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10315 if (!SWIG_IsOK(res1)) {
10316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10317 }
10318 arg1 = reinterpret_cast< wxWindow * >(argp1);
10319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10320 if (!SWIG_IsOK(res2)) {
10321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10322 }
10323 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10324 if (obj2) {
10325 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10326 if (!SWIG_IsOK(ecode3)) {
10327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10328 }
10329 arg3 = static_cast< bool >(val3);
10330 }
10331 {
10332 if (!wxPyCheckForApp()) SWIG_fail;
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 result = (bool)wxShowTip(arg1,arg2,arg3);
10335 wxPyEndAllowThreads(__tstate);
10336 if (PyErr_Occurred()) SWIG_fail;
10337 }
10338 {
10339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10340 }
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj = 0;
10349 wxString *arg1 = 0 ;
10350 size_t arg2 ;
10351 wxTipProvider *result = 0 ;
10352 bool temp1 = false ;
10353 size_t val2 ;
10354 int ecode2 = 0 ;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 char * kwnames[] = {
10358 (char *) "filename",(char *) "currentTip", NULL
10359 };
10360
10361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10362 {
10363 arg1 = wxString_in_helper(obj0);
10364 if (arg1 == NULL) SWIG_fail;
10365 temp1 = true;
10366 }
10367 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10368 if (!SWIG_IsOK(ecode2)) {
10369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10370 }
10371 arg2 = static_cast< size_t >(val2);
10372 {
10373 if (!wxPyCheckForApp()) SWIG_fail;
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10376 wxPyEndAllowThreads(__tstate);
10377 if (PyErr_Occurred()) SWIG_fail;
10378 }
10379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10380 {
10381 if (temp1)
10382 delete arg1;
10383 }
10384 return resultobj;
10385 fail:
10386 {
10387 if (temp1)
10388 delete arg1;
10389 }
10390 return NULL;
10391 }
10392
10393
10394 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj = 0;
10396 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10397 int arg2 = (int) wxID_ANY ;
10398 wxPyTimer *result = 0 ;
10399 void *argp1 = 0 ;
10400 int res1 = 0 ;
10401 int val2 ;
10402 int ecode2 = 0 ;
10403 PyObject * obj0 = 0 ;
10404 PyObject * obj1 = 0 ;
10405 char * kwnames[] = {
10406 (char *) "owner",(char *) "id", NULL
10407 };
10408
10409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10410 if (obj0) {
10411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10412 if (!SWIG_IsOK(res1)) {
10413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10414 }
10415 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10416 }
10417 if (obj1) {
10418 ecode2 = SWIG_AsVal_int(obj1, &val2);
10419 if (!SWIG_IsOK(ecode2)) {
10420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10421 }
10422 arg2 = static_cast< int >(val2);
10423 }
10424 {
10425 if (!wxPyCheckForApp()) SWIG_fail;
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10439 PyObject *resultobj = 0;
10440 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10441 void *argp1 = 0 ;
10442 int res1 = 0 ;
10443 PyObject *swig_obj[1] ;
10444
10445 if (!args) SWIG_fail;
10446 swig_obj[0] = args;
10447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10448 if (!SWIG_IsOK(res1)) {
10449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10450 }
10451 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 delete arg1;
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 resultobj = SWIG_Py_Void();
10460 return resultobj;
10461 fail:
10462 return NULL;
10463 }
10464
10465
10466 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10467 PyObject *resultobj = 0;
10468 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10469 PyObject *arg2 = (PyObject *) 0 ;
10470 PyObject *arg3 = (PyObject *) 0 ;
10471 int arg4 = (int) 1 ;
10472 void *argp1 = 0 ;
10473 int res1 = 0 ;
10474 int val4 ;
10475 int ecode4 = 0 ;
10476 PyObject * obj0 = 0 ;
10477 PyObject * obj1 = 0 ;
10478 PyObject * obj2 = 0 ;
10479 PyObject * obj3 = 0 ;
10480 char * kwnames[] = {
10481 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10482 };
10483
10484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10486 if (!SWIG_IsOK(res1)) {
10487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10488 }
10489 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10490 arg2 = obj1;
10491 arg3 = obj2;
10492 if (obj3) {
10493 ecode4 = SWIG_AsVal_int(obj3, &val4);
10494 if (!SWIG_IsOK(ecode4)) {
10495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10496 }
10497 arg4 = static_cast< int >(val4);
10498 }
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 resultobj = SWIG_Py_Void();
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10513 PyObject *resultobj = 0;
10514 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10515 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10516 int arg3 = (int) wxID_ANY ;
10517 void *argp1 = 0 ;
10518 int res1 = 0 ;
10519 void *argp2 = 0 ;
10520 int res2 = 0 ;
10521 int val3 ;
10522 int ecode3 = 0 ;
10523 PyObject * obj0 = 0 ;
10524 PyObject * obj1 = 0 ;
10525 PyObject * obj2 = 0 ;
10526 char * kwnames[] = {
10527 (char *) "self",(char *) "owner",(char *) "id", NULL
10528 };
10529
10530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10534 }
10535 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10537 if (!SWIG_IsOK(res2)) {
10538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10539 }
10540 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10541 if (obj2) {
10542 ecode3 = SWIG_AsVal_int(obj2, &val3);
10543 if (!SWIG_IsOK(ecode3)) {
10544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10545 }
10546 arg3 = static_cast< int >(val3);
10547 }
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 (arg1)->SetOwner(arg2,arg3);
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 resultobj = SWIG_Py_Void();
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10562 PyObject *resultobj = 0;
10563 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10564 wxEvtHandler *result = 0 ;
10565 void *argp1 = 0 ;
10566 int res1 = 0 ;
10567 PyObject *swig_obj[1] ;
10568
10569 if (!args) SWIG_fail;
10570 swig_obj[0] = args;
10571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10572 if (!SWIG_IsOK(res1)) {
10573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10574 }
10575 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10576 {
10577 PyThreadState* __tstate = wxPyBeginAllowThreads();
10578 result = (wxEvtHandler *)(arg1)->GetOwner();
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 {
10583 resultobj = wxPyMake_wxObject(result, 0);
10584 }
10585 return resultobj;
10586 fail:
10587 return NULL;
10588 }
10589
10590
10591 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10592 PyObject *resultobj = 0;
10593 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10594 int arg2 = (int) -1 ;
10595 bool arg3 = (bool) false ;
10596 bool result;
10597 void *argp1 = 0 ;
10598 int res1 = 0 ;
10599 int val2 ;
10600 int ecode2 = 0 ;
10601 bool val3 ;
10602 int ecode3 = 0 ;
10603 PyObject * obj0 = 0 ;
10604 PyObject * obj1 = 0 ;
10605 PyObject * obj2 = 0 ;
10606 char * kwnames[] = {
10607 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10608 };
10609
10610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10612 if (!SWIG_IsOK(res1)) {
10613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10614 }
10615 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10616 if (obj1) {
10617 ecode2 = SWIG_AsVal_int(obj1, &val2);
10618 if (!SWIG_IsOK(ecode2)) {
10619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10620 }
10621 arg2 = static_cast< int >(val2);
10622 }
10623 if (obj2) {
10624 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10625 if (!SWIG_IsOK(ecode3)) {
10626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10627 }
10628 arg3 = static_cast< bool >(val3);
10629 }
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = (bool)(arg1)->Start(arg2,arg3);
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 {
10637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10638 }
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10646 PyObject *resultobj = 0;
10647 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 PyObject *swig_obj[1] ;
10651
10652 if (!args) SWIG_fail;
10653 swig_obj[0] = args;
10654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10657 }
10658 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10659 {
10660 PyThreadState* __tstate = wxPyBeginAllowThreads();
10661 (arg1)->Stop();
10662 wxPyEndAllowThreads(__tstate);
10663 if (PyErr_Occurred()) SWIG_fail;
10664 }
10665 resultobj = SWIG_Py_Void();
10666 return resultobj;
10667 fail:
10668 return NULL;
10669 }
10670
10671
10672 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10673 PyObject *resultobj = 0;
10674 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10675 void *argp1 = 0 ;
10676 int res1 = 0 ;
10677 PyObject *swig_obj[1] ;
10678
10679 if (!args) SWIG_fail;
10680 swig_obj[0] = args;
10681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10682 if (!SWIG_IsOK(res1)) {
10683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10684 }
10685 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 (arg1)->Notify();
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 resultobj = SWIG_Py_Void();
10693 return resultobj;
10694 fail:
10695 return NULL;
10696 }
10697
10698
10699 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10700 PyObject *resultobj = 0;
10701 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10702 bool result;
10703 void *argp1 = 0 ;
10704 int res1 = 0 ;
10705 PyObject *swig_obj[1] ;
10706
10707 if (!args) SWIG_fail;
10708 swig_obj[0] = args;
10709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10710 if (!SWIG_IsOK(res1)) {
10711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10712 }
10713 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 {
10721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10722 }
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10730 PyObject *resultobj = 0;
10731 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10732 int result;
10733 void *argp1 = 0 ;
10734 int res1 = 0 ;
10735 PyObject *swig_obj[1] ;
10736
10737 if (!args) SWIG_fail;
10738 swig_obj[0] = args;
10739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10740 if (!SWIG_IsOK(res1)) {
10741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10742 }
10743 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10744 {
10745 PyThreadState* __tstate = wxPyBeginAllowThreads();
10746 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10747 wxPyEndAllowThreads(__tstate);
10748 if (PyErr_Occurred()) SWIG_fail;
10749 }
10750 resultobj = SWIG_From_int(static_cast< int >(result));
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10758 PyObject *resultobj = 0;
10759 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10760 int result;
10761 void *argp1 = 0 ;
10762 int res1 = 0 ;
10763 PyObject *swig_obj[1] ;
10764
10765 if (!args) SWIG_fail;
10766 swig_obj[0] = args;
10767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10768 if (!SWIG_IsOK(res1)) {
10769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10770 }
10771 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10772 {
10773 PyThreadState* __tstate = wxPyBeginAllowThreads();
10774 result = (int)((wxPyTimer const *)arg1)->GetId();
10775 wxPyEndAllowThreads(__tstate);
10776 if (PyErr_Occurred()) SWIG_fail;
10777 }
10778 resultobj = SWIG_From_int(static_cast< int >(result));
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10786 PyObject *resultobj = 0;
10787 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10788 bool result;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 PyObject *swig_obj[1] ;
10792
10793 if (!args) SWIG_fail;
10794 swig_obj[0] = args;
10795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10796 if (!SWIG_IsOK(res1)) {
10797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10798 }
10799 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10808 }
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10816 PyObject *obj;
10817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10818 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10819 return SWIG_Py_Void();
10820 }
10821
10822 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10823 return SWIG_Python_InitShadowInstance(args);
10824 }
10825
10826 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10827 PyObject *resultobj = 0;
10828 int arg1 = (int) 0 ;
10829 int arg2 = (int) 0 ;
10830 wxTimerEvent *result = 0 ;
10831 int val1 ;
10832 int ecode1 = 0 ;
10833 int val2 ;
10834 int ecode2 = 0 ;
10835 PyObject * obj0 = 0 ;
10836 PyObject * obj1 = 0 ;
10837 char * kwnames[] = {
10838 (char *) "timerid",(char *) "interval", NULL
10839 };
10840
10841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10842 if (obj0) {
10843 ecode1 = SWIG_AsVal_int(obj0, &val1);
10844 if (!SWIG_IsOK(ecode1)) {
10845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10846 }
10847 arg1 = static_cast< int >(val1);
10848 }
10849 if (obj1) {
10850 ecode2 = SWIG_AsVal_int(obj1, &val2);
10851 if (!SWIG_IsOK(ecode2)) {
10852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10853 }
10854 arg2 = static_cast< int >(val2);
10855 }
10856 {
10857 PyThreadState* __tstate = wxPyBeginAllowThreads();
10858 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10859 wxPyEndAllowThreads(__tstate);
10860 if (PyErr_Occurred()) SWIG_fail;
10861 }
10862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10863 return resultobj;
10864 fail:
10865 return NULL;
10866 }
10867
10868
10869 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10870 PyObject *resultobj = 0;
10871 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10872 int result;
10873 void *argp1 = 0 ;
10874 int res1 = 0 ;
10875 PyObject *swig_obj[1] ;
10876
10877 if (!args) SWIG_fail;
10878 swig_obj[0] = args;
10879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10880 if (!SWIG_IsOK(res1)) {
10881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10882 }
10883 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10884 {
10885 PyThreadState* __tstate = wxPyBeginAllowThreads();
10886 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10887 wxPyEndAllowThreads(__tstate);
10888 if (PyErr_Occurred()) SWIG_fail;
10889 }
10890 resultobj = SWIG_From_int(static_cast< int >(result));
10891 return resultobj;
10892 fail:
10893 return NULL;
10894 }
10895
10896
10897 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10898 PyObject *obj;
10899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10900 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10901 return SWIG_Py_Void();
10902 }
10903
10904 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10905 return SWIG_Python_InitShadowInstance(args);
10906 }
10907
10908 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10909 PyObject *resultobj = 0;
10910 wxTimer *arg1 = 0 ;
10911 wxTimerRunner *result = 0 ;
10912 void *argp1 = 0 ;
10913 int res1 = 0 ;
10914
10915 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10917 if (!SWIG_IsOK(res1)) {
10918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10919 }
10920 if (!argp1) {
10921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10922 }
10923 arg1 = reinterpret_cast< wxTimer * >(argp1);
10924 {
10925 if (!wxPyCheckForApp()) SWIG_fail;
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10928 wxPyEndAllowThreads(__tstate);
10929 if (PyErr_Occurred()) SWIG_fail;
10930 }
10931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10932 return resultobj;
10933 fail:
10934 return NULL;
10935 }
10936
10937
10938 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10939 PyObject *resultobj = 0;
10940 wxTimer *arg1 = 0 ;
10941 int arg2 ;
10942 bool arg3 = (bool) false ;
10943 wxTimerRunner *result = 0 ;
10944 void *argp1 = 0 ;
10945 int res1 = 0 ;
10946 int val2 ;
10947 int ecode2 = 0 ;
10948 bool val3 ;
10949 int ecode3 = 0 ;
10950
10951 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10953 if (!SWIG_IsOK(res1)) {
10954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10955 }
10956 if (!argp1) {
10957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10958 }
10959 arg1 = reinterpret_cast< wxTimer * >(argp1);
10960 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10961 if (!SWIG_IsOK(ecode2)) {
10962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10963 }
10964 arg2 = static_cast< int >(val2);
10965 if (swig_obj[2]) {
10966 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10967 if (!SWIG_IsOK(ecode3)) {
10968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10969 }
10970 arg3 = static_cast< bool >(val3);
10971 }
10972 {
10973 if (!wxPyCheckForApp()) SWIG_fail;
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10980 return resultobj;
10981 fail:
10982 return NULL;
10983 }
10984
10985
10986 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10987 int argc;
10988 PyObject *argv[4];
10989
10990 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10991 --argc;
10992 if (argc == 1) {
10993 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10994 }
10995 if ((argc >= 2) && (argc <= 3)) {
10996 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10997 }
10998
10999 fail:
11000 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11001 return NULL;
11002 }
11003
11004
11005 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11006 PyObject *resultobj = 0;
11007 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11008 void *argp1 = 0 ;
11009 int res1 = 0 ;
11010 PyObject *swig_obj[1] ;
11011
11012 if (!args) SWIG_fail;
11013 swig_obj[0] = args;
11014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11015 if (!SWIG_IsOK(res1)) {
11016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11017 }
11018 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11019 {
11020 PyThreadState* __tstate = wxPyBeginAllowThreads();
11021 delete arg1;
11022
11023 wxPyEndAllowThreads(__tstate);
11024 if (PyErr_Occurred()) SWIG_fail;
11025 }
11026 resultobj = SWIG_Py_Void();
11027 return resultobj;
11028 fail:
11029 return NULL;
11030 }
11031
11032
11033 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11034 PyObject *resultobj = 0;
11035 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11036 int arg2 ;
11037 bool arg3 = (bool) false ;
11038 void *argp1 = 0 ;
11039 int res1 = 0 ;
11040 int val2 ;
11041 int ecode2 = 0 ;
11042 bool val3 ;
11043 int ecode3 = 0 ;
11044 PyObject * obj0 = 0 ;
11045 PyObject * obj1 = 0 ;
11046 PyObject * obj2 = 0 ;
11047 char * kwnames[] = {
11048 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11049 };
11050
11051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11053 if (!SWIG_IsOK(res1)) {
11054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11055 }
11056 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11057 ecode2 = SWIG_AsVal_int(obj1, &val2);
11058 if (!SWIG_IsOK(ecode2)) {
11059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11060 }
11061 arg2 = static_cast< int >(val2);
11062 if (obj2) {
11063 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11064 if (!SWIG_IsOK(ecode3)) {
11065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11066 }
11067 arg3 = static_cast< bool >(val3);
11068 }
11069 {
11070 PyThreadState* __tstate = wxPyBeginAllowThreads();
11071 (arg1)->Start(arg2,arg3);
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 resultobj = SWIG_Py_Void();
11076 return resultobj;
11077 fail:
11078 return NULL;
11079 }
11080
11081
11082 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11083 PyObject *obj;
11084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11085 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11086 return SWIG_Py_Void();
11087 }
11088
11089 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11090 return SWIG_Python_InitShadowInstance(args);
11091 }
11092
11093 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11094 PyObject *resultobj = 0;
11095 wxLog *result = 0 ;
11096
11097 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11098 {
11099 PyThreadState* __tstate = wxPyBeginAllowThreads();
11100 result = (wxLog *)new wxLog();
11101 wxPyEndAllowThreads(__tstate);
11102 if (PyErr_Occurred()) SWIG_fail;
11103 }
11104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11105 return resultobj;
11106 fail:
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11112 PyObject *resultobj = 0;
11113 wxLog *arg1 = (wxLog *) 0 ;
11114 void *argp1 = 0 ;
11115 int res1 = 0 ;
11116 PyObject *swig_obj[1] ;
11117
11118 if (!args) SWIG_fail;
11119 swig_obj[0] = args;
11120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11121 if (!SWIG_IsOK(res1)) {
11122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11123 }
11124 arg1 = reinterpret_cast< wxLog * >(argp1);
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 delete arg1;
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 resultobj = SWIG_Py_Void();
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 bool result;
11142
11143 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 result = (bool)wxLog::IsEnabled();
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 {
11151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11152 }
11153 return resultobj;
11154 fail:
11155 return NULL;
11156 }
11157
11158
11159 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11160 PyObject *resultobj = 0;
11161 bool arg1 = (bool) true ;
11162 bool result;
11163 bool val1 ;
11164 int ecode1 = 0 ;
11165 PyObject * obj0 = 0 ;
11166 char * kwnames[] = {
11167 (char *) "doIt", NULL
11168 };
11169
11170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11171 if (obj0) {
11172 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11173 if (!SWIG_IsOK(ecode1)) {
11174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11175 }
11176 arg1 = static_cast< bool >(val1);
11177 }
11178 {
11179 PyThreadState* __tstate = wxPyBeginAllowThreads();
11180 result = (bool)wxLog::EnableLogging(arg1);
11181 wxPyEndAllowThreads(__tstate);
11182 if (PyErr_Occurred()) SWIG_fail;
11183 }
11184 {
11185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11186 }
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11194 PyObject *resultobj = 0;
11195 wxLogLevel arg1 ;
11196 wxChar *arg2 = (wxChar *) 0 ;
11197 time_t arg3 ;
11198 unsigned long val1 ;
11199 int ecode1 = 0 ;
11200 void *argp2 = 0 ;
11201 int res2 = 0 ;
11202 unsigned int val3 ;
11203 int ecode3 = 0 ;
11204 PyObject * obj0 = 0 ;
11205 PyObject * obj1 = 0 ;
11206 PyObject * obj2 = 0 ;
11207 char * kwnames[] = {
11208 (char *) "level",(char *) "szString",(char *) "t", NULL
11209 };
11210
11211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11212 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11213 if (!SWIG_IsOK(ecode1)) {
11214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11215 }
11216 arg1 = static_cast< wxLogLevel >(val1);
11217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11218 if (!SWIG_IsOK(res2)) {
11219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11220 }
11221 arg2 = reinterpret_cast< wxChar * >(argp2);
11222 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11223 if (!SWIG_IsOK(ecode3)) {
11224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11225 }
11226 arg3 = static_cast< time_t >(val3);
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 resultobj = SWIG_Py_Void();
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11241 PyObject *resultobj = 0;
11242 wxLog *arg1 = (wxLog *) 0 ;
11243 void *argp1 = 0 ;
11244 int res1 = 0 ;
11245 PyObject *swig_obj[1] ;
11246
11247 if (!args) SWIG_fail;
11248 swig_obj[0] = args;
11249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11250 if (!SWIG_IsOK(res1)) {
11251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11252 }
11253 arg1 = reinterpret_cast< wxLog * >(argp1);
11254 {
11255 PyThreadState* __tstate = wxPyBeginAllowThreads();
11256 (arg1)->Flush();
11257 wxPyEndAllowThreads(__tstate);
11258 if (PyErr_Occurred()) SWIG_fail;
11259 }
11260 resultobj = SWIG_Py_Void();
11261 return resultobj;
11262 fail:
11263 return NULL;
11264 }
11265
11266
11267 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11268 PyObject *resultobj = 0;
11269
11270 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 wxLog::FlushActive();
11274 wxPyEndAllowThreads(__tstate);
11275 if (PyErr_Occurred()) SWIG_fail;
11276 }
11277 resultobj = SWIG_Py_Void();
11278 return resultobj;
11279 fail:
11280 return NULL;
11281 }
11282
11283
11284 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11285 PyObject *resultobj = 0;
11286 wxLog *result = 0 ;
11287
11288 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11289 {
11290 PyThreadState* __tstate = wxPyBeginAllowThreads();
11291 result = (wxLog *)wxLog::GetActiveTarget();
11292 wxPyEndAllowThreads(__tstate);
11293 if (PyErr_Occurred()) SWIG_fail;
11294 }
11295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11296 return resultobj;
11297 fail:
11298 return NULL;
11299 }
11300
11301
11302 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11303 PyObject *resultobj = 0;
11304 wxLog *arg1 = (wxLog *) 0 ;
11305 wxLog *result = 0 ;
11306 int res1 = 0 ;
11307 PyObject * obj0 = 0 ;
11308 char * kwnames[] = {
11309 (char *) "pLogger", NULL
11310 };
11311
11312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11313 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11314 if (!SWIG_IsOK(res1)) {
11315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11316 }
11317 {
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11320 wxPyEndAllowThreads(__tstate);
11321 if (PyErr_Occurred()) SWIG_fail;
11322 }
11323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11324 return resultobj;
11325 fail:
11326 return NULL;
11327 }
11328
11329
11330 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11331 PyObject *resultobj = 0;
11332
11333 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 wxLog::Suspend();
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11348 PyObject *resultobj = 0;
11349
11350 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 wxLog::Resume();
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 return resultobj;
11359 fail:
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11365 PyObject *resultobj = 0;
11366 bool arg1 = (bool) true ;
11367 bool val1 ;
11368 int ecode1 = 0 ;
11369 PyObject * obj0 = 0 ;
11370 char * kwnames[] = {
11371 (char *) "bVerbose", NULL
11372 };
11373
11374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11375 if (obj0) {
11376 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11377 if (!SWIG_IsOK(ecode1)) {
11378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11379 }
11380 arg1 = static_cast< bool >(val1);
11381 }
11382 {
11383 PyThreadState* __tstate = wxPyBeginAllowThreads();
11384 wxLog::SetVerbose(arg1);
11385 wxPyEndAllowThreads(__tstate);
11386 if (PyErr_Occurred()) SWIG_fail;
11387 }
11388 resultobj = SWIG_Py_Void();
11389 return resultobj;
11390 fail:
11391 return NULL;
11392 }
11393
11394
11395 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11396 PyObject *resultobj = 0;
11397 wxLogLevel arg1 ;
11398 unsigned long val1 ;
11399 int ecode1 = 0 ;
11400 PyObject * obj0 = 0 ;
11401 char * kwnames[] = {
11402 (char *) "logLevel", NULL
11403 };
11404
11405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11406 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11407 if (!SWIG_IsOK(ecode1)) {
11408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11409 }
11410 arg1 = static_cast< wxLogLevel >(val1);
11411 {
11412 PyThreadState* __tstate = wxPyBeginAllowThreads();
11413 wxLog::SetLogLevel(arg1);
11414 wxPyEndAllowThreads(__tstate);
11415 if (PyErr_Occurred()) SWIG_fail;
11416 }
11417 resultobj = SWIG_Py_Void();
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11425 PyObject *resultobj = 0;
11426
11427 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 wxLog::DontCreateOnDemand();
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 resultobj = SWIG_Py_Void();
11435 return resultobj;
11436 fail:
11437 return NULL;
11438 }
11439
11440
11441 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11442 PyObject *resultobj = 0;
11443 wxTraceMask arg1 ;
11444 unsigned long val1 ;
11445 int ecode1 = 0 ;
11446 PyObject * obj0 = 0 ;
11447 char * kwnames[] = {
11448 (char *) "ulMask", NULL
11449 };
11450
11451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11452 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11453 if (!SWIG_IsOK(ecode1)) {
11454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11455 }
11456 arg1 = static_cast< wxTraceMask >(val1);
11457 {
11458 PyThreadState* __tstate = wxPyBeginAllowThreads();
11459 wxLog::SetTraceMask(arg1);
11460 wxPyEndAllowThreads(__tstate);
11461 if (PyErr_Occurred()) SWIG_fail;
11462 }
11463 resultobj = SWIG_Py_Void();
11464 return resultobj;
11465 fail:
11466 return NULL;
11467 }
11468
11469
11470 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11471 PyObject *resultobj = 0;
11472 wxString *arg1 = 0 ;
11473 bool temp1 = false ;
11474 PyObject * obj0 = 0 ;
11475 char * kwnames[] = {
11476 (char *) "str", NULL
11477 };
11478
11479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11480 {
11481 arg1 = wxString_in_helper(obj0);
11482 if (arg1 == NULL) SWIG_fail;
11483 temp1 = true;
11484 }
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 wxLog::AddTraceMask((wxString const &)*arg1);
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 resultobj = SWIG_Py_Void();
11492 {
11493 if (temp1)
11494 delete arg1;
11495 }
11496 return resultobj;
11497 fail:
11498 {
11499 if (temp1)
11500 delete arg1;
11501 }
11502 return NULL;
11503 }
11504
11505
11506 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11507 PyObject *resultobj = 0;
11508 wxString *arg1 = 0 ;
11509 bool temp1 = false ;
11510 PyObject * obj0 = 0 ;
11511 char * kwnames[] = {
11512 (char *) "str", NULL
11513 };
11514
11515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11516 {
11517 arg1 = wxString_in_helper(obj0);
11518 if (arg1 == NULL) SWIG_fail;
11519 temp1 = true;
11520 }
11521 {
11522 PyThreadState* __tstate = wxPyBeginAllowThreads();
11523 wxLog::RemoveTraceMask((wxString const &)*arg1);
11524 wxPyEndAllowThreads(__tstate);
11525 if (PyErr_Occurred()) SWIG_fail;
11526 }
11527 resultobj = SWIG_Py_Void();
11528 {
11529 if (temp1)
11530 delete arg1;
11531 }
11532 return resultobj;
11533 fail:
11534 {
11535 if (temp1)
11536 delete arg1;
11537 }
11538 return NULL;
11539 }
11540
11541
11542 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11543 PyObject *resultobj = 0;
11544
11545 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11546 {
11547 PyThreadState* __tstate = wxPyBeginAllowThreads();
11548 wxLog::ClearTraceMasks();
11549 wxPyEndAllowThreads(__tstate);
11550 if (PyErr_Occurred()) SWIG_fail;
11551 }
11552 resultobj = SWIG_Py_Void();
11553 return resultobj;
11554 fail:
11555 return NULL;
11556 }
11557
11558
11559 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11560 PyObject *resultobj = 0;
11561 wxArrayString *result = 0 ;
11562
11563 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11564 {
11565 PyThreadState* __tstate = wxPyBeginAllowThreads();
11566 {
11567 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11568 result = (wxArrayString *) &_result_ref;
11569 }
11570 wxPyEndAllowThreads(__tstate);
11571 if (PyErr_Occurred()) SWIG_fail;
11572 }
11573 {
11574 resultobj = wxArrayString2PyList_helper(*result);
11575 }
11576 return resultobj;
11577 fail:
11578 return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11583 PyObject *resultobj = 0;
11584 wxChar *arg1 = (wxChar *) 0 ;
11585 void *argp1 = 0 ;
11586 int res1 = 0 ;
11587 PyObject * obj0 = 0 ;
11588 char * kwnames[] = {
11589 (char *) "ts", NULL
11590 };
11591
11592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11594 if (!SWIG_IsOK(res1)) {
11595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11596 }
11597 arg1 = reinterpret_cast< wxChar * >(argp1);
11598 {
11599 PyThreadState* __tstate = wxPyBeginAllowThreads();
11600 wxLog::SetTimestamp((wxChar const *)arg1);
11601 wxPyEndAllowThreads(__tstate);
11602 if (PyErr_Occurred()) SWIG_fail;
11603 }
11604 resultobj = SWIG_Py_Void();
11605 return resultobj;
11606 fail:
11607 return NULL;
11608 }
11609
11610
11611 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11612 PyObject *resultobj = 0;
11613 bool result;
11614
11615 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 result = (bool)wxLog::GetVerbose();
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 {
11623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11624 }
11625 return resultobj;
11626 fail:
11627 return NULL;
11628 }
11629
11630
11631 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11632 PyObject *resultobj = 0;
11633 wxTraceMask result;
11634
11635 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11636 {
11637 PyThreadState* __tstate = wxPyBeginAllowThreads();
11638 result = (wxTraceMask)wxLog::GetTraceMask();
11639 wxPyEndAllowThreads(__tstate);
11640 if (PyErr_Occurred()) SWIG_fail;
11641 }
11642 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11650 PyObject *resultobj = 0;
11651 wxChar *arg1 = (wxChar *) 0 ;
11652 bool result;
11653 void *argp1 = 0 ;
11654 int res1 = 0 ;
11655 PyObject * obj0 = 0 ;
11656 char * kwnames[] = {
11657 (char *) "mask", NULL
11658 };
11659
11660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11662 if (!SWIG_IsOK(res1)) {
11663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11664 }
11665 arg1 = reinterpret_cast< wxChar * >(argp1);
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11674 }
11675 return resultobj;
11676 fail:
11677 return NULL;
11678 }
11679
11680
11681 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11682 PyObject *resultobj = 0;
11683 wxLogLevel result;
11684
11685 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11686 {
11687 PyThreadState* __tstate = wxPyBeginAllowThreads();
11688 result = (wxLogLevel)wxLog::GetLogLevel();
11689 wxPyEndAllowThreads(__tstate);
11690 if (PyErr_Occurred()) SWIG_fail;
11691 }
11692 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11693 return resultobj;
11694 fail:
11695 return NULL;
11696 }
11697
11698
11699 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11700 PyObject *resultobj = 0;
11701 wxChar *result = 0 ;
11702
11703 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 result = (wxChar *)wxLog::GetTimestamp();
11707 wxPyEndAllowThreads(__tstate);
11708 if (PyErr_Occurred()) SWIG_fail;
11709 }
11710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11718 PyObject *resultobj = 0;
11719 wxString result;
11720
11721 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11722 {
11723 PyThreadState* __tstate = wxPyBeginAllowThreads();
11724 result = wxLog_TimeStamp();
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 {
11729 #if wxUSE_UNICODE
11730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11731 #else
11732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11733 #endif
11734 }
11735 return resultobj;
11736 fail:
11737 return NULL;
11738 }
11739
11740
11741 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11742 PyObject *resultobj = 0;
11743 wxLog *arg1 = (wxLog *) 0 ;
11744 void *argp1 = 0 ;
11745 int res1 = 0 ;
11746 PyObject *swig_obj[1] ;
11747
11748 if (!args) SWIG_fail;
11749 swig_obj[0] = args;
11750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11751 if (!SWIG_IsOK(res1)) {
11752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11753 }
11754 arg1 = reinterpret_cast< wxLog * >(argp1);
11755 {
11756 PyThreadState* __tstate = wxPyBeginAllowThreads();
11757 wxLog_Destroy(arg1);
11758 wxPyEndAllowThreads(__tstate);
11759 if (PyErr_Occurred()) SWIG_fail;
11760 }
11761 resultobj = SWIG_Py_Void();
11762 return resultobj;
11763 fail:
11764 return NULL;
11765 }
11766
11767
11768 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11769 PyObject *obj;
11770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11771 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11772 return SWIG_Py_Void();
11773 }
11774
11775 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11776 return SWIG_Python_InitShadowInstance(args);
11777 }
11778
11779 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11780 PyObject *resultobj = 0;
11781 wxLogStderr *result = 0 ;
11782
11783 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = (wxLogStderr *)new wxLogStderr();
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11791 return resultobj;
11792 fail:
11793 return NULL;
11794 }
11795
11796
11797 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798 PyObject *obj;
11799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11800 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11801 return SWIG_Py_Void();
11802 }
11803
11804 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11805 return SWIG_Python_InitShadowInstance(args);
11806 }
11807
11808 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11809 PyObject *resultobj = 0;
11810 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11811 wxLogTextCtrl *result = 0 ;
11812 void *argp1 = 0 ;
11813 int res1 = 0 ;
11814 PyObject * obj0 = 0 ;
11815 char * kwnames[] = {
11816 (char *) "pTextCtrl", NULL
11817 };
11818
11819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11821 if (!SWIG_IsOK(res1)) {
11822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11823 }
11824 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11825 {
11826 PyThreadState* __tstate = wxPyBeginAllowThreads();
11827 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11839 PyObject *obj;
11840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11841 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11842 return SWIG_Py_Void();
11843 }
11844
11845 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11846 return SWIG_Python_InitShadowInstance(args);
11847 }
11848
11849 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxLogGui *result = 0 ;
11852
11853 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11854 {
11855 PyThreadState* __tstate = wxPyBeginAllowThreads();
11856 result = (wxLogGui *)new wxLogGui();
11857 wxPyEndAllowThreads(__tstate);
11858 if (PyErr_Occurred()) SWIG_fail;
11859 }
11860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11861 return resultobj;
11862 fail:
11863 return NULL;
11864 }
11865
11866
11867 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11868 PyObject *obj;
11869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11870 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11871 return SWIG_Py_Void();
11872 }
11873
11874 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11875 return SWIG_Python_InitShadowInstance(args);
11876 }
11877
11878 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11879 PyObject *resultobj = 0;
11880 wxFrame *arg1 = (wxFrame *) 0 ;
11881 wxString *arg2 = 0 ;
11882 bool arg3 = (bool) true ;
11883 bool arg4 = (bool) true ;
11884 wxLogWindow *result = 0 ;
11885 void *argp1 = 0 ;
11886 int res1 = 0 ;
11887 bool temp2 = false ;
11888 bool val3 ;
11889 int ecode3 = 0 ;
11890 bool val4 ;
11891 int ecode4 = 0 ;
11892 PyObject * obj0 = 0 ;
11893 PyObject * obj1 = 0 ;
11894 PyObject * obj2 = 0 ;
11895 PyObject * obj3 = 0 ;
11896 char * kwnames[] = {
11897 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11898 };
11899
11900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11902 if (!SWIG_IsOK(res1)) {
11903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11904 }
11905 arg1 = reinterpret_cast< wxFrame * >(argp1);
11906 {
11907 arg2 = wxString_in_helper(obj1);
11908 if (arg2 == NULL) SWIG_fail;
11909 temp2 = true;
11910 }
11911 if (obj2) {
11912 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11913 if (!SWIG_IsOK(ecode3)) {
11914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11915 }
11916 arg3 = static_cast< bool >(val3);
11917 }
11918 if (obj3) {
11919 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11920 if (!SWIG_IsOK(ecode4)) {
11921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11922 }
11923 arg4 = static_cast< bool >(val4);
11924 }
11925 {
11926 PyThreadState* __tstate = wxPyBeginAllowThreads();
11927 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11928 wxPyEndAllowThreads(__tstate);
11929 if (PyErr_Occurred()) SWIG_fail;
11930 }
11931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11932 {
11933 if (temp2)
11934 delete arg2;
11935 }
11936 return resultobj;
11937 fail:
11938 {
11939 if (temp2)
11940 delete arg2;
11941 }
11942 return NULL;
11943 }
11944
11945
11946 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11947 PyObject *resultobj = 0;
11948 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11949 bool arg2 = (bool) true ;
11950 void *argp1 = 0 ;
11951 int res1 = 0 ;
11952 bool val2 ;
11953 int ecode2 = 0 ;
11954 PyObject * obj0 = 0 ;
11955 PyObject * obj1 = 0 ;
11956 char * kwnames[] = {
11957 (char *) "self",(char *) "bShow", NULL
11958 };
11959
11960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11962 if (!SWIG_IsOK(res1)) {
11963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11964 }
11965 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11966 if (obj1) {
11967 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11968 if (!SWIG_IsOK(ecode2)) {
11969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11970 }
11971 arg2 = static_cast< bool >(val2);
11972 }
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 (arg1)->Show(arg2);
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 resultobj = SWIG_Py_Void();
11980 return resultobj;
11981 fail:
11982 return NULL;
11983 }
11984
11985
11986 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11987 PyObject *resultobj = 0;
11988 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11989 wxFrame *result = 0 ;
11990 void *argp1 = 0 ;
11991 int res1 = 0 ;
11992 PyObject *swig_obj[1] ;
11993
11994 if (!args) SWIG_fail;
11995 swig_obj[0] = args;
11996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11997 if (!SWIG_IsOK(res1)) {
11998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11999 }
12000 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12001 {
12002 PyThreadState* __tstate = wxPyBeginAllowThreads();
12003 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12004 wxPyEndAllowThreads(__tstate);
12005 if (PyErr_Occurred()) SWIG_fail;
12006 }
12007 {
12008 resultobj = wxPyMake_wxObject(result, (bool)0);
12009 }
12010 return resultobj;
12011 fail:
12012 return NULL;
12013 }
12014
12015
12016 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12017 PyObject *resultobj = 0;
12018 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12019 wxLog *result = 0 ;
12020 void *argp1 = 0 ;
12021 int res1 = 0 ;
12022 PyObject *swig_obj[1] ;
12023
12024 if (!args) SWIG_fail;
12025 swig_obj[0] = args;
12026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12027 if (!SWIG_IsOK(res1)) {
12028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12029 }
12030 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12034 wxPyEndAllowThreads(__tstate);
12035 if (PyErr_Occurred()) SWIG_fail;
12036 }
12037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12038 return resultobj;
12039 fail:
12040 return NULL;
12041 }
12042
12043
12044 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12045 PyObject *resultobj = 0;
12046 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12047 bool result;
12048 void *argp1 = 0 ;
12049 int res1 = 0 ;
12050 PyObject *swig_obj[1] ;
12051
12052 if (!args) SWIG_fail;
12053 swig_obj[0] = args;
12054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12055 if (!SWIG_IsOK(res1)) {
12056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12057 }
12058 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 {
12066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12067 }
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12075 PyObject *resultobj = 0;
12076 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12077 bool arg2 ;
12078 void *argp1 = 0 ;
12079 int res1 = 0 ;
12080 bool val2 ;
12081 int ecode2 = 0 ;
12082 PyObject * obj0 = 0 ;
12083 PyObject * obj1 = 0 ;
12084 char * kwnames[] = {
12085 (char *) "self",(char *) "bDoPass", NULL
12086 };
12087
12088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12090 if (!SWIG_IsOK(res1)) {
12091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12092 }
12093 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12094 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12095 if (!SWIG_IsOK(ecode2)) {
12096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12097 }
12098 arg2 = static_cast< bool >(val2);
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 (arg1)->PassMessages(arg2);
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 resultobj = SWIG_Py_Void();
12106 return resultobj;
12107 fail:
12108 return NULL;
12109 }
12110
12111
12112 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12113 PyObject *obj;
12114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12115 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
12116 return SWIG_Py_Void();
12117 }
12118
12119 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12120 return SWIG_Python_InitShadowInstance(args);
12121 }
12122
12123 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12124 PyObject *resultobj = 0;
12125 wxLog *arg1 = (wxLog *) 0 ;
12126 wxLogChain *result = 0 ;
12127 void *argp1 = 0 ;
12128 int res1 = 0 ;
12129 PyObject * obj0 = 0 ;
12130 char * kwnames[] = {
12131 (char *) "logger", NULL
12132 };
12133
12134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12136 if (!SWIG_IsOK(res1)) {
12137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12138 }
12139 arg1 = reinterpret_cast< wxLog * >(argp1);
12140 {
12141 PyThreadState* __tstate = wxPyBeginAllowThreads();
12142 result = (wxLogChain *)new wxLogChain(arg1);
12143 wxPyEndAllowThreads(__tstate);
12144 if (PyErr_Occurred()) SWIG_fail;
12145 }
12146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12154 PyObject *resultobj = 0;
12155 wxLogChain *arg1 = (wxLogChain *) 0 ;
12156 wxLog *arg2 = (wxLog *) 0 ;
12157 void *argp1 = 0 ;
12158 int res1 = 0 ;
12159 void *argp2 = 0 ;
12160 int res2 = 0 ;
12161 PyObject * obj0 = 0 ;
12162 PyObject * obj1 = 0 ;
12163 char * kwnames[] = {
12164 (char *) "self",(char *) "logger", NULL
12165 };
12166
12167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12169 if (!SWIG_IsOK(res1)) {
12170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12171 }
12172 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12174 if (!SWIG_IsOK(res2)) {
12175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12176 }
12177 arg2 = reinterpret_cast< wxLog * >(argp2);
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 (arg1)->SetLog(arg2);
12181 wxPyEndAllowThreads(__tstate);
12182 if (PyErr_Occurred()) SWIG_fail;
12183 }
12184 resultobj = SWIG_Py_Void();
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj = 0;
12193 wxLogChain *arg1 = (wxLogChain *) 0 ;
12194 bool arg2 ;
12195 void *argp1 = 0 ;
12196 int res1 = 0 ;
12197 bool val2 ;
12198 int ecode2 = 0 ;
12199 PyObject * obj0 = 0 ;
12200 PyObject * obj1 = 0 ;
12201 char * kwnames[] = {
12202 (char *) "self",(char *) "bDoPass", NULL
12203 };
12204
12205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12207 if (!SWIG_IsOK(res1)) {
12208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12209 }
12210 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12211 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12212 if (!SWIG_IsOK(ecode2)) {
12213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12214 }
12215 arg2 = static_cast< bool >(val2);
12216 {
12217 PyThreadState* __tstate = wxPyBeginAllowThreads();
12218 (arg1)->PassMessages(arg2);
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 resultobj = SWIG_Py_Void();
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12230 PyObject *resultobj = 0;
12231 wxLogChain *arg1 = (wxLogChain *) 0 ;
12232 bool result;
12233 void *argp1 = 0 ;
12234 int res1 = 0 ;
12235 PyObject *swig_obj[1] ;
12236
12237 if (!args) SWIG_fail;
12238 swig_obj[0] = args;
12239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12240 if (!SWIG_IsOK(res1)) {
12241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12242 }
12243 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12244 {
12245 PyThreadState* __tstate = wxPyBeginAllowThreads();
12246 result = (bool)(arg1)->IsPassingMessages();
12247 wxPyEndAllowThreads(__tstate);
12248 if (PyErr_Occurred()) SWIG_fail;
12249 }
12250 {
12251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12252 }
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12260 PyObject *resultobj = 0;
12261 wxLogChain *arg1 = (wxLogChain *) 0 ;
12262 wxLog *result = 0 ;
12263 void *argp1 = 0 ;
12264 int res1 = 0 ;
12265 PyObject *swig_obj[1] ;
12266
12267 if (!args) SWIG_fail;
12268 swig_obj[0] = args;
12269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12270 if (!SWIG_IsOK(res1)) {
12271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12272 }
12273 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = (wxLog *)(arg1)->GetOldLog();
12277 wxPyEndAllowThreads(__tstate);
12278 if (PyErr_Occurred()) SWIG_fail;
12279 }
12280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12288 PyObject *obj;
12289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12290 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12291 return SWIG_Py_Void();
12292 }
12293
12294 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12295 return SWIG_Python_InitShadowInstance(args);
12296 }
12297
12298 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12299 PyObject *resultobj = 0;
12300 wxLogBuffer *result = 0 ;
12301
12302 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12303 {
12304 PyThreadState* __tstate = wxPyBeginAllowThreads();
12305 result = (wxLogBuffer *)new wxLogBuffer();
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12310 return resultobj;
12311 fail:
12312 return NULL;
12313 }
12314
12315
12316 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12317 PyObject *resultobj = 0;
12318 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12319 wxString *result = 0 ;
12320 void *argp1 = 0 ;
12321 int res1 = 0 ;
12322 PyObject *swig_obj[1] ;
12323
12324 if (!args) SWIG_fail;
12325 swig_obj[0] = args;
12326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12327 if (!SWIG_IsOK(res1)) {
12328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12329 }
12330 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12331 {
12332 PyThreadState* __tstate = wxPyBeginAllowThreads();
12333 {
12334 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12335 result = (wxString *) &_result_ref;
12336 }
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 {
12341 #if wxUSE_UNICODE
12342 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12343 #else
12344 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12345 #endif
12346 }
12347 return resultobj;
12348 fail:
12349 return NULL;
12350 }
12351
12352
12353 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12354 PyObject *obj;
12355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12356 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12357 return SWIG_Py_Void();
12358 }
12359
12360 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12361 return SWIG_Python_InitShadowInstance(args);
12362 }
12363
12364 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12365 PyObject *resultobj = 0;
12366 unsigned long result;
12367
12368 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 result = (unsigned long)wxSysErrorCode();
12372 wxPyEndAllowThreads(__tstate);
12373 if (PyErr_Occurred()) SWIG_fail;
12374 }
12375 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12376 return resultobj;
12377 fail:
12378 return NULL;
12379 }
12380
12381
12382 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12383 PyObject *resultobj = 0;
12384 unsigned long arg1 = (unsigned long) 0 ;
12385 wxString result;
12386 unsigned long val1 ;
12387 int ecode1 = 0 ;
12388 PyObject * obj0 = 0 ;
12389 char * kwnames[] = {
12390 (char *) "nErrCode", NULL
12391 };
12392
12393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12394 if (obj0) {
12395 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12396 if (!SWIG_IsOK(ecode1)) {
12397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12398 }
12399 arg1 = static_cast< unsigned long >(val1);
12400 }
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = wxSysErrorMsg(arg1);
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 {
12408 #if wxUSE_UNICODE
12409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12410 #else
12411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12412 #endif
12413 }
12414 return resultobj;
12415 fail:
12416 return NULL;
12417 }
12418
12419
12420 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12421 PyObject *resultobj = 0;
12422 wxString *arg1 = 0 ;
12423 bool temp1 = false ;
12424 PyObject * obj0 = 0 ;
12425 char * kwnames[] = {
12426 (char *) "msg", NULL
12427 };
12428
12429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12430 {
12431 arg1 = wxString_in_helper(obj0);
12432 if (arg1 == NULL) SWIG_fail;
12433 temp1 = true;
12434 }
12435 {
12436 PyThreadState* __tstate = wxPyBeginAllowThreads();
12437 wxPyLogFatalError((wxString const &)*arg1);
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 resultobj = SWIG_Py_Void();
12442 {
12443 if (temp1)
12444 delete arg1;
12445 }
12446 return resultobj;
12447 fail:
12448 {
12449 if (temp1)
12450 delete arg1;
12451 }
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj = 0;
12458 wxString *arg1 = 0 ;
12459 bool temp1 = false ;
12460 PyObject * obj0 = 0 ;
12461 char * kwnames[] = {
12462 (char *) "msg", NULL
12463 };
12464
12465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12466 {
12467 arg1 = wxString_in_helper(obj0);
12468 if (arg1 == NULL) SWIG_fail;
12469 temp1 = true;
12470 }
12471 {
12472 PyThreadState* __tstate = wxPyBeginAllowThreads();
12473 wxPyLogError((wxString const &)*arg1);
12474 wxPyEndAllowThreads(__tstate);
12475 if (PyErr_Occurred()) SWIG_fail;
12476 }
12477 resultobj = SWIG_Py_Void();
12478 {
12479 if (temp1)
12480 delete arg1;
12481 }
12482 return resultobj;
12483 fail:
12484 {
12485 if (temp1)
12486 delete arg1;
12487 }
12488 return NULL;
12489 }
12490
12491
12492 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12493 PyObject *resultobj = 0;
12494 wxString *arg1 = 0 ;
12495 bool temp1 = false ;
12496 PyObject * obj0 = 0 ;
12497 char * kwnames[] = {
12498 (char *) "msg", NULL
12499 };
12500
12501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12502 {
12503 arg1 = wxString_in_helper(obj0);
12504 if (arg1 == NULL) SWIG_fail;
12505 temp1 = true;
12506 }
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 wxPyLogWarning((wxString const &)*arg1);
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 resultobj = SWIG_Py_Void();
12514 {
12515 if (temp1)
12516 delete arg1;
12517 }
12518 return resultobj;
12519 fail:
12520 {
12521 if (temp1)
12522 delete arg1;
12523 }
12524 return NULL;
12525 }
12526
12527
12528 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj = 0;
12530 wxString *arg1 = 0 ;
12531 bool temp1 = false ;
12532 PyObject * obj0 = 0 ;
12533 char * kwnames[] = {
12534 (char *) "msg", NULL
12535 };
12536
12537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12538 {
12539 arg1 = wxString_in_helper(obj0);
12540 if (arg1 == NULL) SWIG_fail;
12541 temp1 = true;
12542 }
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 wxPyLogMessage((wxString const &)*arg1);
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 resultobj = SWIG_Py_Void();
12550 {
12551 if (temp1)
12552 delete arg1;
12553 }
12554 return resultobj;
12555 fail:
12556 {
12557 if (temp1)
12558 delete arg1;
12559 }
12560 return NULL;
12561 }
12562
12563
12564 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12565 PyObject *resultobj = 0;
12566 wxString *arg1 = 0 ;
12567 bool temp1 = false ;
12568 PyObject * obj0 = 0 ;
12569 char * kwnames[] = {
12570 (char *) "msg", NULL
12571 };
12572
12573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12574 {
12575 arg1 = wxString_in_helper(obj0);
12576 if (arg1 == NULL) SWIG_fail;
12577 temp1 = true;
12578 }
12579 {
12580 PyThreadState* __tstate = wxPyBeginAllowThreads();
12581 wxPyLogInfo((wxString const &)*arg1);
12582 wxPyEndAllowThreads(__tstate);
12583 if (PyErr_Occurred()) SWIG_fail;
12584 }
12585 resultobj = SWIG_Py_Void();
12586 {
12587 if (temp1)
12588 delete arg1;
12589 }
12590 return resultobj;
12591 fail:
12592 {
12593 if (temp1)
12594 delete arg1;
12595 }
12596 return NULL;
12597 }
12598
12599
12600 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12601 PyObject *resultobj = 0;
12602 wxString *arg1 = 0 ;
12603 bool temp1 = false ;
12604 PyObject * obj0 = 0 ;
12605 char * kwnames[] = {
12606 (char *) "msg", NULL
12607 };
12608
12609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12610 {
12611 arg1 = wxString_in_helper(obj0);
12612 if (arg1 == NULL) SWIG_fail;
12613 temp1 = true;
12614 }
12615 {
12616 PyThreadState* __tstate = wxPyBeginAllowThreads();
12617 wxPyLogDebug((wxString const &)*arg1);
12618 wxPyEndAllowThreads(__tstate);
12619 if (PyErr_Occurred()) SWIG_fail;
12620 }
12621 resultobj = SWIG_Py_Void();
12622 {
12623 if (temp1)
12624 delete arg1;
12625 }
12626 return resultobj;
12627 fail:
12628 {
12629 if (temp1)
12630 delete arg1;
12631 }
12632 return NULL;
12633 }
12634
12635
12636 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12637 PyObject *resultobj = 0;
12638 wxString *arg1 = 0 ;
12639 bool temp1 = false ;
12640 PyObject * obj0 = 0 ;
12641 char * kwnames[] = {
12642 (char *) "msg", NULL
12643 };
12644
12645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12646 {
12647 arg1 = wxString_in_helper(obj0);
12648 if (arg1 == NULL) SWIG_fail;
12649 temp1 = true;
12650 }
12651 {
12652 PyThreadState* __tstate = wxPyBeginAllowThreads();
12653 wxPyLogVerbose((wxString const &)*arg1);
12654 wxPyEndAllowThreads(__tstate);
12655 if (PyErr_Occurred()) SWIG_fail;
12656 }
12657 resultobj = SWIG_Py_Void();
12658 {
12659 if (temp1)
12660 delete arg1;
12661 }
12662 return resultobj;
12663 fail:
12664 {
12665 if (temp1)
12666 delete arg1;
12667 }
12668 return NULL;
12669 }
12670
12671
12672 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12673 PyObject *resultobj = 0;
12674 wxString *arg1 = 0 ;
12675 bool temp1 = false ;
12676 PyObject * obj0 = 0 ;
12677 char * kwnames[] = {
12678 (char *) "msg", NULL
12679 };
12680
12681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12682 {
12683 arg1 = wxString_in_helper(obj0);
12684 if (arg1 == NULL) SWIG_fail;
12685 temp1 = true;
12686 }
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 wxPyLogStatus((wxString const &)*arg1);
12690 wxPyEndAllowThreads(__tstate);
12691 if (PyErr_Occurred()) SWIG_fail;
12692 }
12693 resultobj = SWIG_Py_Void();
12694 {
12695 if (temp1)
12696 delete arg1;
12697 }
12698 return resultobj;
12699 fail:
12700 {
12701 if (temp1)
12702 delete arg1;
12703 }
12704 return NULL;
12705 }
12706
12707
12708 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12709 PyObject *resultobj = 0;
12710 wxFrame *arg1 = (wxFrame *) 0 ;
12711 wxString *arg2 = 0 ;
12712 void *argp1 = 0 ;
12713 int res1 = 0 ;
12714 bool temp2 = false ;
12715 PyObject * obj0 = 0 ;
12716 PyObject * obj1 = 0 ;
12717 char * kwnames[] = {
12718 (char *) "pFrame",(char *) "msg", NULL
12719 };
12720
12721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12723 if (!SWIG_IsOK(res1)) {
12724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12725 }
12726 arg1 = reinterpret_cast< wxFrame * >(argp1);
12727 {
12728 arg2 = wxString_in_helper(obj1);
12729 if (arg2 == NULL) SWIG_fail;
12730 temp2 = true;
12731 }
12732 {
12733 PyThreadState* __tstate = wxPyBeginAllowThreads();
12734 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12735 wxPyEndAllowThreads(__tstate);
12736 if (PyErr_Occurred()) SWIG_fail;
12737 }
12738 resultobj = SWIG_Py_Void();
12739 {
12740 if (temp2)
12741 delete arg2;
12742 }
12743 return resultobj;
12744 fail:
12745 {
12746 if (temp2)
12747 delete arg2;
12748 }
12749 return NULL;
12750 }
12751
12752
12753 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12754 PyObject *resultobj = 0;
12755 wxString *arg1 = 0 ;
12756 bool temp1 = false ;
12757 PyObject * obj0 = 0 ;
12758 char * kwnames[] = {
12759 (char *) "msg", NULL
12760 };
12761
12762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12763 {
12764 arg1 = wxString_in_helper(obj0);
12765 if (arg1 == NULL) SWIG_fail;
12766 temp1 = true;
12767 }
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 wxPyLogSysError((wxString const &)*arg1);
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = SWIG_Py_Void();
12775 {
12776 if (temp1)
12777 delete arg1;
12778 }
12779 return resultobj;
12780 fail:
12781 {
12782 if (temp1)
12783 delete arg1;
12784 }
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12790 PyObject *resultobj = 0;
12791 unsigned long arg1 ;
12792 wxString *arg2 = 0 ;
12793 unsigned long val1 ;
12794 int ecode1 = 0 ;
12795 bool temp2 = false ;
12796 PyObject * obj0 = 0 ;
12797 PyObject * obj1 = 0 ;
12798 char * kwnames[] = {
12799 (char *) "level",(char *) "msg", NULL
12800 };
12801
12802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12803 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12804 if (!SWIG_IsOK(ecode1)) {
12805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12806 }
12807 arg1 = static_cast< unsigned long >(val1);
12808 {
12809 arg2 = wxString_in_helper(obj1);
12810 if (arg2 == NULL) SWIG_fail;
12811 temp2 = true;
12812 }
12813 {
12814 PyThreadState* __tstate = wxPyBeginAllowThreads();
12815 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12816 wxPyEndAllowThreads(__tstate);
12817 if (PyErr_Occurred()) SWIG_fail;
12818 }
12819 resultobj = SWIG_Py_Void();
12820 {
12821 if (temp2)
12822 delete arg2;
12823 }
12824 return resultobj;
12825 fail:
12826 {
12827 if (temp2)
12828 delete arg2;
12829 }
12830 return NULL;
12831 }
12832
12833
12834 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12835 PyObject *resultobj = 0;
12836 unsigned long arg1 ;
12837 wxString *arg2 = 0 ;
12838 unsigned long val1 ;
12839 int ecode1 = 0 ;
12840 bool temp2 = false ;
12841
12842 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12843 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12844 if (!SWIG_IsOK(ecode1)) {
12845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12846 }
12847 arg1 = static_cast< unsigned long >(val1);
12848 {
12849 arg2 = wxString_in_helper(swig_obj[1]);
12850 if (arg2 == NULL) SWIG_fail;
12851 temp2 = true;
12852 }
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 wxPyLogTrace(arg1,(wxString const &)*arg2);
12856 wxPyEndAllowThreads(__tstate);
12857 if (PyErr_Occurred()) SWIG_fail;
12858 }
12859 resultobj = SWIG_Py_Void();
12860 {
12861 if (temp2)
12862 delete arg2;
12863 }
12864 return resultobj;
12865 fail:
12866 {
12867 if (temp2)
12868 delete arg2;
12869 }
12870 return NULL;
12871 }
12872
12873
12874 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12875 PyObject *resultobj = 0;
12876 wxString *arg1 = 0 ;
12877 wxString *arg2 = 0 ;
12878 bool temp1 = false ;
12879 bool temp2 = false ;
12880
12881 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12882 {
12883 arg1 = wxString_in_helper(swig_obj[0]);
12884 if (arg1 == NULL) SWIG_fail;
12885 temp1 = true;
12886 }
12887 {
12888 arg2 = wxString_in_helper(swig_obj[1]);
12889 if (arg2 == NULL) SWIG_fail;
12890 temp2 = true;
12891 }
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 resultobj = SWIG_Py_Void();
12899 {
12900 if (temp1)
12901 delete arg1;
12902 }
12903 {
12904 if (temp2)
12905 delete arg2;
12906 }
12907 return resultobj;
12908 fail:
12909 {
12910 if (temp1)
12911 delete arg1;
12912 }
12913 {
12914 if (temp2)
12915 delete arg2;
12916 }
12917 return NULL;
12918 }
12919
12920
12921 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12922 int argc;
12923 PyObject *argv[3];
12924
12925 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12926 --argc;
12927 if (argc == 2) {
12928 int _v = 0;
12929 {
12930 {
12931 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12932 }
12933 }
12934 if (!_v) goto check_1;
12935 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12936 }
12937 check_1:
12938
12939 if (argc == 2) {
12940 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12941 }
12942
12943 fail:
12944 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12945 return NULL;
12946 }
12947
12948
12949 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj = 0;
12951 wxString *arg1 = 0 ;
12952 wxString *arg2 = 0 ;
12953 bool temp1 = false ;
12954 bool temp2 = false ;
12955 PyObject * obj0 = 0 ;
12956 PyObject * obj1 = 0 ;
12957 char * kwnames[] = {
12958 (char *) "title",(char *) "text", NULL
12959 };
12960
12961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12962 {
12963 arg1 = wxString_in_helper(obj0);
12964 if (arg1 == NULL) SWIG_fail;
12965 temp1 = true;
12966 }
12967 {
12968 arg2 = wxString_in_helper(obj1);
12969 if (arg2 == NULL) SWIG_fail;
12970 temp2 = true;
12971 }
12972 {
12973 PyThreadState* __tstate = wxPyBeginAllowThreads();
12974 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 resultobj = SWIG_Py_Void();
12979 {
12980 if (temp1)
12981 delete arg1;
12982 }
12983 {
12984 if (temp2)
12985 delete arg2;
12986 }
12987 return resultobj;
12988 fail:
12989 {
12990 if (temp1)
12991 delete arg1;
12992 }
12993 {
12994 if (temp2)
12995 delete arg2;
12996 }
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13002 PyObject *resultobj = 0;
13003 wxLogNull *result = 0 ;
13004
13005 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13006 {
13007 PyThreadState* __tstate = wxPyBeginAllowThreads();
13008 result = (wxLogNull *)new wxLogNull();
13009 wxPyEndAllowThreads(__tstate);
13010 if (PyErr_Occurred()) SWIG_fail;
13011 }
13012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13013 return resultobj;
13014 fail:
13015 return NULL;
13016 }
13017
13018
13019 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13020 PyObject *resultobj = 0;
13021 wxLogNull *arg1 = (wxLogNull *) 0 ;
13022 void *argp1 = 0 ;
13023 int res1 = 0 ;
13024 PyObject *swig_obj[1] ;
13025
13026 if (!args) SWIG_fail;
13027 swig_obj[0] = args;
13028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13029 if (!SWIG_IsOK(res1)) {
13030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13031 }
13032 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13033 {
13034 PyThreadState* __tstate = wxPyBeginAllowThreads();
13035 delete arg1;
13036
13037 wxPyEndAllowThreads(__tstate);
13038 if (PyErr_Occurred()) SWIG_fail;
13039 }
13040 resultobj = SWIG_Py_Void();
13041 return resultobj;
13042 fail:
13043 return NULL;
13044 }
13045
13046
13047 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13048 PyObject *obj;
13049 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13050 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13051 return SWIG_Py_Void();
13052 }
13053
13054 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13055 return SWIG_Python_InitShadowInstance(args);
13056 }
13057
13058 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13059 PyObject *resultobj = 0;
13060 wxPyLog *result = 0 ;
13061
13062 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
13063 {
13064 PyThreadState* __tstate = wxPyBeginAllowThreads();
13065 result = (wxPyLog *)new wxPyLog();
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
13070 return resultobj;
13071 fail:
13072 return NULL;
13073 }
13074
13075
13076 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13077 PyObject *resultobj = 0;
13078 wxPyLog *arg1 = (wxPyLog *) 0 ;
13079 PyObject *arg2 = (PyObject *) 0 ;
13080 PyObject *arg3 = (PyObject *) 0 ;
13081 void *argp1 = 0 ;
13082 int res1 = 0 ;
13083 PyObject * obj0 = 0 ;
13084 PyObject * obj1 = 0 ;
13085 PyObject * obj2 = 0 ;
13086 char * kwnames[] = {
13087 (char *) "self",(char *) "self",(char *) "_class", NULL
13088 };
13089
13090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
13092 if (!SWIG_IsOK(res1)) {
13093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
13094 }
13095 arg1 = reinterpret_cast< wxPyLog * >(argp1);
13096 arg2 = obj1;
13097 arg3 = obj2;
13098 {
13099 PyThreadState* __tstate = wxPyBeginAllowThreads();
13100 (arg1)->_setCallbackInfo(arg2,arg3);
13101 wxPyEndAllowThreads(__tstate);
13102 if (PyErr_Occurred()) SWIG_fail;
13103 }
13104 resultobj = SWIG_Py_Void();
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13112 PyObject *obj;
13113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13114 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
13115 return SWIG_Py_Void();
13116 }
13117
13118 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13119 return SWIG_Python_InitShadowInstance(args);
13120 }
13121
13122 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13123 PyObject *resultobj = 0;
13124 int arg1 ;
13125 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13126 int arg3 = (int) wxKILL_NOCHILDREN ;
13127 wxKillError result;
13128 int val1 ;
13129 int ecode1 = 0 ;
13130 int val2 ;
13131 int ecode2 = 0 ;
13132 int val3 ;
13133 int ecode3 = 0 ;
13134 PyObject * obj0 = 0 ;
13135 PyObject * obj1 = 0 ;
13136 PyObject * obj2 = 0 ;
13137 char * kwnames[] = {
13138 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13139 };
13140
13141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13142 ecode1 = SWIG_AsVal_int(obj0, &val1);
13143 if (!SWIG_IsOK(ecode1)) {
13144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13145 }
13146 arg1 = static_cast< int >(val1);
13147 if (obj1) {
13148 ecode2 = SWIG_AsVal_int(obj1, &val2);
13149 if (!SWIG_IsOK(ecode2)) {
13150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13151 }
13152 arg2 = static_cast< wxSignal >(val2);
13153 }
13154 if (obj2) {
13155 ecode3 = SWIG_AsVal_int(obj2, &val3);
13156 if (!SWIG_IsOK(ecode3)) {
13157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13158 }
13159 arg3 = static_cast< int >(val3);
13160 }
13161 {
13162 PyThreadState* __tstate = wxPyBeginAllowThreads();
13163 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13164 wxPyEndAllowThreads(__tstate);
13165 if (PyErr_Occurred()) SWIG_fail;
13166 }
13167 resultobj = SWIG_From_int(static_cast< int >(result));
13168 return resultobj;
13169 fail:
13170 return NULL;
13171 }
13172
13173
13174 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13175 PyObject *resultobj = 0;
13176 int arg1 ;
13177 bool result;
13178 int val1 ;
13179 int ecode1 = 0 ;
13180 PyObject * obj0 = 0 ;
13181 char * kwnames[] = {
13182 (char *) "pid", NULL
13183 };
13184
13185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13186 ecode1 = SWIG_AsVal_int(obj0, &val1);
13187 if (!SWIG_IsOK(ecode1)) {
13188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13189 }
13190 arg1 = static_cast< int >(val1);
13191 {
13192 PyThreadState* __tstate = wxPyBeginAllowThreads();
13193 result = (bool)wxPyProcess::Exists(arg1);
13194 wxPyEndAllowThreads(__tstate);
13195 if (PyErr_Occurred()) SWIG_fail;
13196 }
13197 {
13198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13199 }
13200 return resultobj;
13201 fail:
13202 return NULL;
13203 }
13204
13205
13206 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13207 PyObject *resultobj = 0;
13208 wxString *arg1 = 0 ;
13209 int arg2 = (int) wxEXEC_ASYNC ;
13210 wxPyProcess *result = 0 ;
13211 bool temp1 = false ;
13212 int val2 ;
13213 int ecode2 = 0 ;
13214 PyObject * obj0 = 0 ;
13215 PyObject * obj1 = 0 ;
13216 char * kwnames[] = {
13217 (char *) "cmd",(char *) "flags", NULL
13218 };
13219
13220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13221 {
13222 arg1 = wxString_in_helper(obj0);
13223 if (arg1 == NULL) SWIG_fail;
13224 temp1 = true;
13225 }
13226 if (obj1) {
13227 ecode2 = SWIG_AsVal_int(obj1, &val2);
13228 if (!SWIG_IsOK(ecode2)) {
13229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13230 }
13231 arg2 = static_cast< int >(val2);
13232 }
13233 {
13234 PyThreadState* __tstate = wxPyBeginAllowThreads();
13235 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13236 wxPyEndAllowThreads(__tstate);
13237 if (PyErr_Occurred()) SWIG_fail;
13238 }
13239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13240 {
13241 if (temp1)
13242 delete arg1;
13243 }
13244 return resultobj;
13245 fail:
13246 {
13247 if (temp1)
13248 delete arg1;
13249 }
13250 return NULL;
13251 }
13252
13253
13254 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13255 PyObject *resultobj = 0;
13256 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13257 int arg2 = (int) -1 ;
13258 wxPyProcess *result = 0 ;
13259 void *argp1 = 0 ;
13260 int res1 = 0 ;
13261 int val2 ;
13262 int ecode2 = 0 ;
13263 PyObject * obj0 = 0 ;
13264 PyObject * obj1 = 0 ;
13265 char * kwnames[] = {
13266 (char *) "parent",(char *) "id", NULL
13267 };
13268
13269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13270 if (obj0) {
13271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13272 if (!SWIG_IsOK(res1)) {
13273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13274 }
13275 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13276 }
13277 if (obj1) {
13278 ecode2 = SWIG_AsVal_int(obj1, &val2);
13279 if (!SWIG_IsOK(ecode2)) {
13280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13281 }
13282 arg2 = static_cast< int >(val2);
13283 }
13284 {
13285 PyThreadState* __tstate = wxPyBeginAllowThreads();
13286 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj = 0;
13299 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13300 PyObject *arg2 = (PyObject *) 0 ;
13301 PyObject *arg3 = (PyObject *) 0 ;
13302 void *argp1 = 0 ;
13303 int res1 = 0 ;
13304 PyObject * obj0 = 0 ;
13305 PyObject * obj1 = 0 ;
13306 PyObject * obj2 = 0 ;
13307 char * kwnames[] = {
13308 (char *) "self",(char *) "self",(char *) "_class", NULL
13309 };
13310
13311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13313 if (!SWIG_IsOK(res1)) {
13314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13315 }
13316 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13317 arg2 = obj1;
13318 arg3 = obj2;
13319 {
13320 PyThreadState* __tstate = wxPyBeginAllowThreads();
13321 (arg1)->_setCallbackInfo(arg2,arg3);
13322 wxPyEndAllowThreads(__tstate);
13323 if (PyErr_Occurred()) SWIG_fail;
13324 }
13325 resultobj = SWIG_Py_Void();
13326 return resultobj;
13327 fail:
13328 return NULL;
13329 }
13330
13331
13332 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13333 PyObject *resultobj = 0;
13334 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13335 int arg2 ;
13336 int arg3 ;
13337 void *argp1 = 0 ;
13338 int res1 = 0 ;
13339 int val2 ;
13340 int ecode2 = 0 ;
13341 int val3 ;
13342 int ecode3 = 0 ;
13343 PyObject * obj0 = 0 ;
13344 PyObject * obj1 = 0 ;
13345 PyObject * obj2 = 0 ;
13346 char * kwnames[] = {
13347 (char *) "self",(char *) "pid",(char *) "status", NULL
13348 };
13349
13350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13352 if (!SWIG_IsOK(res1)) {
13353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13354 }
13355 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13356 ecode2 = SWIG_AsVal_int(obj1, &val2);
13357 if (!SWIG_IsOK(ecode2)) {
13358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13359 }
13360 arg2 = static_cast< int >(val2);
13361 ecode3 = SWIG_AsVal_int(obj2, &val3);
13362 if (!SWIG_IsOK(ecode3)) {
13363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13364 }
13365 arg3 = static_cast< int >(val3);
13366 {
13367 PyThreadState* __tstate = wxPyBeginAllowThreads();
13368 (arg1)->OnTerminate(arg2,arg3);
13369 wxPyEndAllowThreads(__tstate);
13370 if (PyErr_Occurred()) SWIG_fail;
13371 }
13372 resultobj = SWIG_Py_Void();
13373 return resultobj;
13374 fail:
13375 return NULL;
13376 }
13377
13378
13379 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13380 PyObject *resultobj = 0;
13381 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13382 void *argp1 = 0 ;
13383 int res1 = 0 ;
13384 PyObject *swig_obj[1] ;
13385
13386 if (!args) SWIG_fail;
13387 swig_obj[0] = args;
13388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13389 if (!SWIG_IsOK(res1)) {
13390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13391 }
13392 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13393 {
13394 PyThreadState* __tstate = wxPyBeginAllowThreads();
13395 (arg1)->Redirect();
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 resultobj = SWIG_Py_Void();
13400 return resultobj;
13401 fail:
13402 return NULL;
13403 }
13404
13405
13406 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13407 PyObject *resultobj = 0;
13408 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13409 bool result;
13410 void *argp1 = 0 ;
13411 int res1 = 0 ;
13412 PyObject *swig_obj[1] ;
13413
13414 if (!args) SWIG_fail;
13415 swig_obj[0] = args;
13416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13417 if (!SWIG_IsOK(res1)) {
13418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13419 }
13420 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 result = (bool)(arg1)->IsRedirected();
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 {
13428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13429 }
13430 return resultobj;
13431 fail:
13432 return NULL;
13433 }
13434
13435
13436 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13437 PyObject *resultobj = 0;
13438 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13439 void *argp1 = 0 ;
13440 int res1 = 0 ;
13441 PyObject *swig_obj[1] ;
13442
13443 if (!args) SWIG_fail;
13444 swig_obj[0] = args;
13445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13446 if (!SWIG_IsOK(res1)) {
13447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13448 }
13449 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13450 {
13451 PyThreadState* __tstate = wxPyBeginAllowThreads();
13452 (arg1)->Detach();
13453 wxPyEndAllowThreads(__tstate);
13454 if (PyErr_Occurred()) SWIG_fail;
13455 }
13456 resultobj = SWIG_Py_Void();
13457 return resultobj;
13458 fail:
13459 return NULL;
13460 }
13461
13462
13463 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13464 PyObject *resultobj = 0;
13465 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13466 wxInputStream *result = 0 ;
13467 void *argp1 = 0 ;
13468 int res1 = 0 ;
13469 PyObject *swig_obj[1] ;
13470
13471 if (!args) SWIG_fail;
13472 swig_obj[0] = args;
13473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13474 if (!SWIG_IsOK(res1)) {
13475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13476 }
13477 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13478 {
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 result = (wxInputStream *)(arg1)->GetInputStream();
13481 wxPyEndAllowThreads(__tstate);
13482 if (PyErr_Occurred()) SWIG_fail;
13483 }
13484 {
13485 wxPyInputStream * _ptr = NULL;
13486
13487 if (result) {
13488 _ptr = new wxPyInputStream(result);
13489 }
13490 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13491 }
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13499 PyObject *resultobj = 0;
13500 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13501 wxInputStream *result = 0 ;
13502 void *argp1 = 0 ;
13503 int res1 = 0 ;
13504 PyObject *swig_obj[1] ;
13505
13506 if (!args) SWIG_fail;
13507 swig_obj[0] = args;
13508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13509 if (!SWIG_IsOK(res1)) {
13510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13511 }
13512 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = (wxInputStream *)(arg1)->GetErrorStream();
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 {
13520 wxPyInputStream * _ptr = NULL;
13521
13522 if (result) {
13523 _ptr = new wxPyInputStream(result);
13524 }
13525 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13526 }
13527 return resultobj;
13528 fail:
13529 return NULL;
13530 }
13531
13532
13533 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13534 PyObject *resultobj = 0;
13535 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13536 wxOutputStream *result = 0 ;
13537 void *argp1 = 0 ;
13538 int res1 = 0 ;
13539 PyObject *swig_obj[1] ;
13540
13541 if (!args) SWIG_fail;
13542 swig_obj[0] = args;
13543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13544 if (!SWIG_IsOK(res1)) {
13545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13546 }
13547 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13548 {
13549 PyThreadState* __tstate = wxPyBeginAllowThreads();
13550 result = (wxOutputStream *)(arg1)->GetOutputStream();
13551 wxPyEndAllowThreads(__tstate);
13552 if (PyErr_Occurred()) SWIG_fail;
13553 }
13554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13555 return resultobj;
13556 fail:
13557 return NULL;
13558 }
13559
13560
13561 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13562 PyObject *resultobj = 0;
13563 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13564 void *argp1 = 0 ;
13565 int res1 = 0 ;
13566 PyObject *swig_obj[1] ;
13567
13568 if (!args) SWIG_fail;
13569 swig_obj[0] = args;
13570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13571 if (!SWIG_IsOK(res1)) {
13572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13573 }
13574 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13575 {
13576 PyThreadState* __tstate = wxPyBeginAllowThreads();
13577 (arg1)->CloseOutput();
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 resultobj = SWIG_Py_Void();
13582 return resultobj;
13583 fail:
13584 return NULL;
13585 }
13586
13587
13588 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13589 PyObject *resultobj = 0;
13590 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13591 bool result;
13592 void *argp1 = 0 ;
13593 int res1 = 0 ;
13594 PyObject *swig_obj[1] ;
13595
13596 if (!args) SWIG_fail;
13597 swig_obj[0] = args;
13598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13599 if (!SWIG_IsOK(res1)) {
13600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13601 }
13602 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 {
13610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13611 }
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13619 PyObject *resultobj = 0;
13620 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13621 bool result;
13622 void *argp1 = 0 ;
13623 int res1 = 0 ;
13624 PyObject *swig_obj[1] ;
13625
13626 if (!args) SWIG_fail;
13627 swig_obj[0] = args;
13628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13629 if (!SWIG_IsOK(res1)) {
13630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13631 }
13632 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13633 {
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13636 wxPyEndAllowThreads(__tstate);
13637 if (PyErr_Occurred()) SWIG_fail;
13638 }
13639 {
13640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13641 }
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13649 PyObject *resultobj = 0;
13650 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13651 bool result;
13652 void *argp1 = 0 ;
13653 int res1 = 0 ;
13654 PyObject *swig_obj[1] ;
13655
13656 if (!args) SWIG_fail;
13657 swig_obj[0] = args;
13658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13659 if (!SWIG_IsOK(res1)) {
13660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13661 }
13662 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 {
13670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13671 }
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13679 PyObject *obj;
13680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13681 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13682 return SWIG_Py_Void();
13683 }
13684
13685 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13686 return SWIG_Python_InitShadowInstance(args);
13687 }
13688
13689 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj = 0;
13691 int arg1 = (int) 0 ;
13692 int arg2 = (int) 0 ;
13693 int arg3 = (int) 0 ;
13694 wxProcessEvent *result = 0 ;
13695 int val1 ;
13696 int ecode1 = 0 ;
13697 int val2 ;
13698 int ecode2 = 0 ;
13699 int val3 ;
13700 int ecode3 = 0 ;
13701 PyObject * obj0 = 0 ;
13702 PyObject * obj1 = 0 ;
13703 PyObject * obj2 = 0 ;
13704 char * kwnames[] = {
13705 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13706 };
13707
13708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13709 if (obj0) {
13710 ecode1 = SWIG_AsVal_int(obj0, &val1);
13711 if (!SWIG_IsOK(ecode1)) {
13712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13713 }
13714 arg1 = static_cast< int >(val1);
13715 }
13716 if (obj1) {
13717 ecode2 = SWIG_AsVal_int(obj1, &val2);
13718 if (!SWIG_IsOK(ecode2)) {
13719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13720 }
13721 arg2 = static_cast< int >(val2);
13722 }
13723 if (obj2) {
13724 ecode3 = SWIG_AsVal_int(obj2, &val3);
13725 if (!SWIG_IsOK(ecode3)) {
13726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13727 }
13728 arg3 = static_cast< int >(val3);
13729 }
13730 {
13731 PyThreadState* __tstate = wxPyBeginAllowThreads();
13732 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13733 wxPyEndAllowThreads(__tstate);
13734 if (PyErr_Occurred()) SWIG_fail;
13735 }
13736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13737 return resultobj;
13738 fail:
13739 return NULL;
13740 }
13741
13742
13743 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13744 PyObject *resultobj = 0;
13745 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13746 int result;
13747 void *argp1 = 0 ;
13748 int res1 = 0 ;
13749 PyObject *swig_obj[1] ;
13750
13751 if (!args) SWIG_fail;
13752 swig_obj[0] = args;
13753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13754 if (!SWIG_IsOK(res1)) {
13755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13756 }
13757 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13758 {
13759 PyThreadState* __tstate = wxPyBeginAllowThreads();
13760 result = (int)(arg1)->GetPid();
13761 wxPyEndAllowThreads(__tstate);
13762 if (PyErr_Occurred()) SWIG_fail;
13763 }
13764 resultobj = SWIG_From_int(static_cast< int >(result));
13765 return resultobj;
13766 fail:
13767 return NULL;
13768 }
13769
13770
13771 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13772 PyObject *resultobj = 0;
13773 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13774 int result;
13775 void *argp1 = 0 ;
13776 int res1 = 0 ;
13777 PyObject *swig_obj[1] ;
13778
13779 if (!args) SWIG_fail;
13780 swig_obj[0] = args;
13781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13782 if (!SWIG_IsOK(res1)) {
13783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13784 }
13785 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13786 {
13787 PyThreadState* __tstate = wxPyBeginAllowThreads();
13788 result = (int)(arg1)->GetExitCode();
13789 wxPyEndAllowThreads(__tstate);
13790 if (PyErr_Occurred()) SWIG_fail;
13791 }
13792 resultobj = SWIG_From_int(static_cast< int >(result));
13793 return resultobj;
13794 fail:
13795 return NULL;
13796 }
13797
13798
13799 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13800 PyObject *resultobj = 0;
13801 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13802 int arg2 ;
13803 void *argp1 = 0 ;
13804 int res1 = 0 ;
13805 int val2 ;
13806 int ecode2 = 0 ;
13807 PyObject *swig_obj[2] ;
13808
13809 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13811 if (!SWIG_IsOK(res1)) {
13812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13813 }
13814 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13815 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13816 if (!SWIG_IsOK(ecode2)) {
13817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13818 }
13819 arg2 = static_cast< int >(val2);
13820 if (arg1) (arg1)->m_pid = arg2;
13821
13822 resultobj = SWIG_Py_Void();
13823 return resultobj;
13824 fail:
13825 return NULL;
13826 }
13827
13828
13829 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13830 PyObject *resultobj = 0;
13831 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13832 int result;
13833 void *argp1 = 0 ;
13834 int res1 = 0 ;
13835 PyObject *swig_obj[1] ;
13836
13837 if (!args) SWIG_fail;
13838 swig_obj[0] = args;
13839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13840 if (!SWIG_IsOK(res1)) {
13841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13842 }
13843 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13844 result = (int) ((arg1)->m_pid);
13845 resultobj = SWIG_From_int(static_cast< int >(result));
13846 return resultobj;
13847 fail:
13848 return NULL;
13849 }
13850
13851
13852 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13853 PyObject *resultobj = 0;
13854 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13855 int arg2 ;
13856 void *argp1 = 0 ;
13857 int res1 = 0 ;
13858 int val2 ;
13859 int ecode2 = 0 ;
13860 PyObject *swig_obj[2] ;
13861
13862 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13864 if (!SWIG_IsOK(res1)) {
13865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13866 }
13867 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13868 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13869 if (!SWIG_IsOK(ecode2)) {
13870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13871 }
13872 arg2 = static_cast< int >(val2);
13873 if (arg1) (arg1)->m_exitcode = arg2;
13874
13875 resultobj = SWIG_Py_Void();
13876 return resultobj;
13877 fail:
13878 return NULL;
13879 }
13880
13881
13882 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13883 PyObject *resultobj = 0;
13884 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13885 int result;
13886 void *argp1 = 0 ;
13887 int res1 = 0 ;
13888 PyObject *swig_obj[1] ;
13889
13890 if (!args) SWIG_fail;
13891 swig_obj[0] = args;
13892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13893 if (!SWIG_IsOK(res1)) {
13894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13895 }
13896 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13897 result = (int) ((arg1)->m_exitcode);
13898 resultobj = SWIG_From_int(static_cast< int >(result));
13899 return resultobj;
13900 fail:
13901 return NULL;
13902 }
13903
13904
13905 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13906 PyObject *obj;
13907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13908 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13909 return SWIG_Py_Void();
13910 }
13911
13912 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13913 return SWIG_Python_InitShadowInstance(args);
13914 }
13915
13916 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13917 PyObject *resultobj = 0;
13918 wxString *arg1 = 0 ;
13919 int arg2 = (int) wxEXEC_ASYNC ;
13920 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13921 long result;
13922 bool temp1 = false ;
13923 int val2 ;
13924 int ecode2 = 0 ;
13925 void *argp3 = 0 ;
13926 int res3 = 0 ;
13927 PyObject * obj0 = 0 ;
13928 PyObject * obj1 = 0 ;
13929 PyObject * obj2 = 0 ;
13930 char * kwnames[] = {
13931 (char *) "command",(char *) "flags",(char *) "process", NULL
13932 };
13933
13934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13935 {
13936 arg1 = wxString_in_helper(obj0);
13937 if (arg1 == NULL) SWIG_fail;
13938 temp1 = true;
13939 }
13940 if (obj1) {
13941 ecode2 = SWIG_AsVal_int(obj1, &val2);
13942 if (!SWIG_IsOK(ecode2)) {
13943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13944 }
13945 arg2 = static_cast< int >(val2);
13946 }
13947 if (obj2) {
13948 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13949 if (!SWIG_IsOK(res3)) {
13950 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13951 }
13952 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13953 }
13954 {
13955 if (!wxPyCheckForApp()) SWIG_fail;
13956 PyThreadState* __tstate = wxPyBeginAllowThreads();
13957 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13958 wxPyEndAllowThreads(__tstate);
13959 if (PyErr_Occurred()) SWIG_fail;
13960 }
13961 resultobj = SWIG_From_long(static_cast< long >(result));
13962 {
13963 if (temp1)
13964 delete arg1;
13965 }
13966 return resultobj;
13967 fail:
13968 {
13969 if (temp1)
13970 delete arg1;
13971 }
13972 return NULL;
13973 }
13974
13975
13976 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13977 PyObject *resultobj = 0;
13978 long arg1 ;
13979 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13980 wxKillError *arg3 = (wxKillError *) 0 ;
13981 int arg4 = (int) wxKILL_NOCHILDREN ;
13982 int result;
13983 long val1 ;
13984 int ecode1 = 0 ;
13985 int val2 ;
13986 int ecode2 = 0 ;
13987 wxKillError temp3 ;
13988 int val4 ;
13989 int ecode4 = 0 ;
13990 PyObject * obj0 = 0 ;
13991 PyObject * obj1 = 0 ;
13992 PyObject * obj2 = 0 ;
13993 char * kwnames[] = {
13994 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13995 };
13996
13997 {
13998 arg3 = &temp3;
13999 }
14000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14001 ecode1 = SWIG_AsVal_long(obj0, &val1);
14002 if (!SWIG_IsOK(ecode1)) {
14003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14004 }
14005 arg1 = static_cast< long >(val1);
14006 if (obj1) {
14007 ecode2 = SWIG_AsVal_int(obj1, &val2);
14008 if (!SWIG_IsOK(ecode2)) {
14009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14010 }
14011 arg2 = static_cast< wxSignal >(val2);
14012 }
14013 if (obj2) {
14014 ecode4 = SWIG_AsVal_int(obj2, &val4);
14015 if (!SWIG_IsOK(ecode4)) {
14016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14017 }
14018 arg4 = static_cast< int >(val4);
14019 }
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 result = (int)wxKill(arg1,arg2,arg3,arg4);
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_From_int(static_cast< int >(result));
14027 {
14028 PyObject* o;
14029 o = PyInt_FromLong((long) (*arg3));
14030
14031
14032
14033 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14034
14035 }
14036 return resultobj;
14037 fail:
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14043 PyObject *resultobj = 0;
14044 int arg1 = (int) wxJOYSTICK1 ;
14045 wxJoystick *result = 0 ;
14046 int val1 ;
14047 int ecode1 = 0 ;
14048 PyObject * obj0 = 0 ;
14049 char * kwnames[] = {
14050 (char *) "joystick", NULL
14051 };
14052
14053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14054 if (obj0) {
14055 ecode1 = SWIG_AsVal_int(obj0, &val1);
14056 if (!SWIG_IsOK(ecode1)) {
14057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
14058 }
14059 arg1 = static_cast< int >(val1);
14060 }
14061 {
14062 if (!wxPyCheckForApp()) SWIG_fail;
14063 PyThreadState* __tstate = wxPyBeginAllowThreads();
14064 result = (wxJoystick *)new wxJoystick(arg1);
14065 wxPyEndAllowThreads(__tstate);
14066 if (PyErr_Occurred()) SWIG_fail;
14067 }
14068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
14069 return resultobj;
14070 fail:
14071 return NULL;
14072 }
14073
14074
14075 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14076 PyObject *resultobj = 0;
14077 wxJoystick *arg1 = (wxJoystick *) 0 ;
14078 void *argp1 = 0 ;
14079 int res1 = 0 ;
14080 PyObject *swig_obj[1] ;
14081
14082 if (!args) SWIG_fail;
14083 swig_obj[0] = args;
14084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
14085 if (!SWIG_IsOK(res1)) {
14086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
14087 }
14088 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14089 {
14090 PyThreadState* __tstate = wxPyBeginAllowThreads();
14091 delete arg1;
14092
14093 wxPyEndAllowThreads(__tstate);
14094 if (PyErr_Occurred()) SWIG_fail;
14095 }
14096 resultobj = SWIG_Py_Void();
14097 return resultobj;
14098 fail:
14099 return NULL;
14100 }
14101
14102
14103 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14104 PyObject *resultobj = 0;
14105 wxJoystick *arg1 = (wxJoystick *) 0 ;
14106 wxPoint result;
14107 void *argp1 = 0 ;
14108 int res1 = 0 ;
14109 PyObject *swig_obj[1] ;
14110
14111 if (!args) SWIG_fail;
14112 swig_obj[0] = args;
14113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14114 if (!SWIG_IsOK(res1)) {
14115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14116 }
14117 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 result = (arg1)->GetPosition();
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14132 PyObject *resultobj = 0;
14133 wxJoystick *arg1 = (wxJoystick *) 0 ;
14134 int result;
14135 void *argp1 = 0 ;
14136 int res1 = 0 ;
14137 PyObject *swig_obj[1] ;
14138
14139 if (!args) SWIG_fail;
14140 swig_obj[0] = args;
14141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14142 if (!SWIG_IsOK(res1)) {
14143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14144 }
14145 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 result = (int)(arg1)->GetZPosition();
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 resultobj = SWIG_From_int(static_cast< int >(result));
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14160 PyObject *resultobj = 0;
14161 wxJoystick *arg1 = (wxJoystick *) 0 ;
14162 int result;
14163 void *argp1 = 0 ;
14164 int res1 = 0 ;
14165 PyObject *swig_obj[1] ;
14166
14167 if (!args) SWIG_fail;
14168 swig_obj[0] = args;
14169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14170 if (!SWIG_IsOK(res1)) {
14171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14172 }
14173 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14174 {
14175 PyThreadState* __tstate = wxPyBeginAllowThreads();
14176 result = (int)(arg1)->GetButtonState();
14177 wxPyEndAllowThreads(__tstate);
14178 if (PyErr_Occurred()) SWIG_fail;
14179 }
14180 resultobj = SWIG_From_int(static_cast< int >(result));
14181 return resultobj;
14182 fail:
14183 return NULL;
14184 }
14185
14186
14187 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14188 PyObject *resultobj = 0;
14189 wxJoystick *arg1 = (wxJoystick *) 0 ;
14190 int result;
14191 void *argp1 = 0 ;
14192 int res1 = 0 ;
14193 PyObject *swig_obj[1] ;
14194
14195 if (!args) SWIG_fail;
14196 swig_obj[0] = args;
14197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14198 if (!SWIG_IsOK(res1)) {
14199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14200 }
14201 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14202 {
14203 PyThreadState* __tstate = wxPyBeginAllowThreads();
14204 result = (int)(arg1)->GetPOVPosition();
14205 wxPyEndAllowThreads(__tstate);
14206 if (PyErr_Occurred()) SWIG_fail;
14207 }
14208 resultobj = SWIG_From_int(static_cast< int >(result));
14209 return resultobj;
14210 fail:
14211 return NULL;
14212 }
14213
14214
14215 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14216 PyObject *resultobj = 0;
14217 wxJoystick *arg1 = (wxJoystick *) 0 ;
14218 int result;
14219 void *argp1 = 0 ;
14220 int res1 = 0 ;
14221 PyObject *swig_obj[1] ;
14222
14223 if (!args) SWIG_fail;
14224 swig_obj[0] = args;
14225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14226 if (!SWIG_IsOK(res1)) {
14227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14228 }
14229 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 result = (int)(arg1)->GetPOVCTSPosition();
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 resultobj = SWIG_From_int(static_cast< int >(result));
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14244 PyObject *resultobj = 0;
14245 wxJoystick *arg1 = (wxJoystick *) 0 ;
14246 int result;
14247 void *argp1 = 0 ;
14248 int res1 = 0 ;
14249 PyObject *swig_obj[1] ;
14250
14251 if (!args) SWIG_fail;
14252 swig_obj[0] = args;
14253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14254 if (!SWIG_IsOK(res1)) {
14255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14256 }
14257 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14258 {
14259 PyThreadState* __tstate = wxPyBeginAllowThreads();
14260 result = (int)(arg1)->GetRudderPosition();
14261 wxPyEndAllowThreads(__tstate);
14262 if (PyErr_Occurred()) SWIG_fail;
14263 }
14264 resultobj = SWIG_From_int(static_cast< int >(result));
14265 return resultobj;
14266 fail:
14267 return NULL;
14268 }
14269
14270
14271 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14272 PyObject *resultobj = 0;
14273 wxJoystick *arg1 = (wxJoystick *) 0 ;
14274 int result;
14275 void *argp1 = 0 ;
14276 int res1 = 0 ;
14277 PyObject *swig_obj[1] ;
14278
14279 if (!args) SWIG_fail;
14280 swig_obj[0] = args;
14281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14282 if (!SWIG_IsOK(res1)) {
14283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14284 }
14285 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14286 {
14287 PyThreadState* __tstate = wxPyBeginAllowThreads();
14288 result = (int)(arg1)->GetUPosition();
14289 wxPyEndAllowThreads(__tstate);
14290 if (PyErr_Occurred()) SWIG_fail;
14291 }
14292 resultobj = SWIG_From_int(static_cast< int >(result));
14293 return resultobj;
14294 fail:
14295 return NULL;
14296 }
14297
14298
14299 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14300 PyObject *resultobj = 0;
14301 wxJoystick *arg1 = (wxJoystick *) 0 ;
14302 int result;
14303 void *argp1 = 0 ;
14304 int res1 = 0 ;
14305 PyObject *swig_obj[1] ;
14306
14307 if (!args) SWIG_fail;
14308 swig_obj[0] = args;
14309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14310 if (!SWIG_IsOK(res1)) {
14311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14312 }
14313 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14314 {
14315 PyThreadState* __tstate = wxPyBeginAllowThreads();
14316 result = (int)(arg1)->GetVPosition();
14317 wxPyEndAllowThreads(__tstate);
14318 if (PyErr_Occurred()) SWIG_fail;
14319 }
14320 resultobj = SWIG_From_int(static_cast< int >(result));
14321 return resultobj;
14322 fail:
14323 return NULL;
14324 }
14325
14326
14327 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14328 PyObject *resultobj = 0;
14329 wxJoystick *arg1 = (wxJoystick *) 0 ;
14330 int result;
14331 void *argp1 = 0 ;
14332 int res1 = 0 ;
14333 PyObject *swig_obj[1] ;
14334
14335 if (!args) SWIG_fail;
14336 swig_obj[0] = args;
14337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14338 if (!SWIG_IsOK(res1)) {
14339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14340 }
14341 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14342 {
14343 PyThreadState* __tstate = wxPyBeginAllowThreads();
14344 result = (int)(arg1)->GetMovementThreshold();
14345 wxPyEndAllowThreads(__tstate);
14346 if (PyErr_Occurred()) SWIG_fail;
14347 }
14348 resultobj = SWIG_From_int(static_cast< int >(result));
14349 return resultobj;
14350 fail:
14351 return NULL;
14352 }
14353
14354
14355 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14356 PyObject *resultobj = 0;
14357 wxJoystick *arg1 = (wxJoystick *) 0 ;
14358 int arg2 ;
14359 void *argp1 = 0 ;
14360 int res1 = 0 ;
14361 int val2 ;
14362 int ecode2 = 0 ;
14363 PyObject * obj0 = 0 ;
14364 PyObject * obj1 = 0 ;
14365 char * kwnames[] = {
14366 (char *) "self",(char *) "threshold", NULL
14367 };
14368
14369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14371 if (!SWIG_IsOK(res1)) {
14372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14373 }
14374 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14375 ecode2 = SWIG_AsVal_int(obj1, &val2);
14376 if (!SWIG_IsOK(ecode2)) {
14377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14378 }
14379 arg2 = static_cast< int >(val2);
14380 {
14381 PyThreadState* __tstate = wxPyBeginAllowThreads();
14382 (arg1)->SetMovementThreshold(arg2);
14383 wxPyEndAllowThreads(__tstate);
14384 if (PyErr_Occurred()) SWIG_fail;
14385 }
14386 resultobj = SWIG_Py_Void();
14387 return resultobj;
14388 fail:
14389 return NULL;
14390 }
14391
14392
14393 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14394 PyObject *resultobj = 0;
14395 wxJoystick *arg1 = (wxJoystick *) 0 ;
14396 bool result;
14397 void *argp1 = 0 ;
14398 int res1 = 0 ;
14399 PyObject *swig_obj[1] ;
14400
14401 if (!args) SWIG_fail;
14402 swig_obj[0] = args;
14403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14404 if (!SWIG_IsOK(res1)) {
14405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14406 }
14407 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 result = (bool)(arg1)->IsOk();
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 {
14415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14416 }
14417 return resultobj;
14418 fail:
14419 return NULL;
14420 }
14421
14422
14423 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14424 PyObject *resultobj = 0;
14425 wxJoystick *arg1 = (wxJoystick *) 0 ;
14426 int result;
14427 void *argp1 = 0 ;
14428 int res1 = 0 ;
14429 PyObject *swig_obj[1] ;
14430
14431 if (!args) SWIG_fail;
14432 swig_obj[0] = args;
14433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14434 if (!SWIG_IsOK(res1)) {
14435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14436 }
14437 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14438 {
14439 PyThreadState* __tstate = wxPyBeginAllowThreads();
14440 result = (int)(arg1)->GetNumberJoysticks();
14441 wxPyEndAllowThreads(__tstate);
14442 if (PyErr_Occurred()) SWIG_fail;
14443 }
14444 resultobj = SWIG_From_int(static_cast< int >(result));
14445 return resultobj;
14446 fail:
14447 return NULL;
14448 }
14449
14450
14451 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14452 PyObject *resultobj = 0;
14453 wxJoystick *arg1 = (wxJoystick *) 0 ;
14454 int result;
14455 void *argp1 = 0 ;
14456 int res1 = 0 ;
14457 PyObject *swig_obj[1] ;
14458
14459 if (!args) SWIG_fail;
14460 swig_obj[0] = args;
14461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14462 if (!SWIG_IsOK(res1)) {
14463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14464 }
14465 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14466 {
14467 PyThreadState* __tstate = wxPyBeginAllowThreads();
14468 result = (int)(arg1)->GetManufacturerId();
14469 wxPyEndAllowThreads(__tstate);
14470 if (PyErr_Occurred()) SWIG_fail;
14471 }
14472 resultobj = SWIG_From_int(static_cast< int >(result));
14473 return resultobj;
14474 fail:
14475 return NULL;
14476 }
14477
14478
14479 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14480 PyObject *resultobj = 0;
14481 wxJoystick *arg1 = (wxJoystick *) 0 ;
14482 int result;
14483 void *argp1 = 0 ;
14484 int res1 = 0 ;
14485 PyObject *swig_obj[1] ;
14486
14487 if (!args) SWIG_fail;
14488 swig_obj[0] = args;
14489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14490 if (!SWIG_IsOK(res1)) {
14491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14492 }
14493 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14494 {
14495 PyThreadState* __tstate = wxPyBeginAllowThreads();
14496 result = (int)(arg1)->GetProductId();
14497 wxPyEndAllowThreads(__tstate);
14498 if (PyErr_Occurred()) SWIG_fail;
14499 }
14500 resultobj = SWIG_From_int(static_cast< int >(result));
14501 return resultobj;
14502 fail:
14503 return NULL;
14504 }
14505
14506
14507 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14508 PyObject *resultobj = 0;
14509 wxJoystick *arg1 = (wxJoystick *) 0 ;
14510 wxString result;
14511 void *argp1 = 0 ;
14512 int res1 = 0 ;
14513 PyObject *swig_obj[1] ;
14514
14515 if (!args) SWIG_fail;
14516 swig_obj[0] = args;
14517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14518 if (!SWIG_IsOK(res1)) {
14519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14520 }
14521 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14522 {
14523 PyThreadState* __tstate = wxPyBeginAllowThreads();
14524 result = (arg1)->GetProductName();
14525 wxPyEndAllowThreads(__tstate);
14526 if (PyErr_Occurred()) SWIG_fail;
14527 }
14528 {
14529 #if wxUSE_UNICODE
14530 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14531 #else
14532 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14533 #endif
14534 }
14535 return resultobj;
14536 fail:
14537 return NULL;
14538 }
14539
14540
14541 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14542 PyObject *resultobj = 0;
14543 wxJoystick *arg1 = (wxJoystick *) 0 ;
14544 int result;
14545 void *argp1 = 0 ;
14546 int res1 = 0 ;
14547 PyObject *swig_obj[1] ;
14548
14549 if (!args) SWIG_fail;
14550 swig_obj[0] = args;
14551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14552 if (!SWIG_IsOK(res1)) {
14553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14554 }
14555 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14556 {
14557 PyThreadState* __tstate = wxPyBeginAllowThreads();
14558 result = (int)(arg1)->GetXMin();
14559 wxPyEndAllowThreads(__tstate);
14560 if (PyErr_Occurred()) SWIG_fail;
14561 }
14562 resultobj = SWIG_From_int(static_cast< int >(result));
14563 return resultobj;
14564 fail:
14565 return NULL;
14566 }
14567
14568
14569 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14570 PyObject *resultobj = 0;
14571 wxJoystick *arg1 = (wxJoystick *) 0 ;
14572 int result;
14573 void *argp1 = 0 ;
14574 int res1 = 0 ;
14575 PyObject *swig_obj[1] ;
14576
14577 if (!args) SWIG_fail;
14578 swig_obj[0] = args;
14579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14580 if (!SWIG_IsOK(res1)) {
14581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14582 }
14583 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14584 {
14585 PyThreadState* __tstate = wxPyBeginAllowThreads();
14586 result = (int)(arg1)->GetYMin();
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 resultobj = SWIG_From_int(static_cast< int >(result));
14591 return resultobj;
14592 fail:
14593 return NULL;
14594 }
14595
14596
14597 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14598 PyObject *resultobj = 0;
14599 wxJoystick *arg1 = (wxJoystick *) 0 ;
14600 int result;
14601 void *argp1 = 0 ;
14602 int res1 = 0 ;
14603 PyObject *swig_obj[1] ;
14604
14605 if (!args) SWIG_fail;
14606 swig_obj[0] = args;
14607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14608 if (!SWIG_IsOK(res1)) {
14609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14610 }
14611 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14612 {
14613 PyThreadState* __tstate = wxPyBeginAllowThreads();
14614 result = (int)(arg1)->GetZMin();
14615 wxPyEndAllowThreads(__tstate);
14616 if (PyErr_Occurred()) SWIG_fail;
14617 }
14618 resultobj = SWIG_From_int(static_cast< int >(result));
14619 return resultobj;
14620 fail:
14621 return NULL;
14622 }
14623
14624
14625 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14626 PyObject *resultobj = 0;
14627 wxJoystick *arg1 = (wxJoystick *) 0 ;
14628 int result;
14629 void *argp1 = 0 ;
14630 int res1 = 0 ;
14631 PyObject *swig_obj[1] ;
14632
14633 if (!args) SWIG_fail;
14634 swig_obj[0] = args;
14635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14636 if (!SWIG_IsOK(res1)) {
14637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14638 }
14639 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14640 {
14641 PyThreadState* __tstate = wxPyBeginAllowThreads();
14642 result = (int)(arg1)->GetXMax();
14643 wxPyEndAllowThreads(__tstate);
14644 if (PyErr_Occurred()) SWIG_fail;
14645 }
14646 resultobj = SWIG_From_int(static_cast< int >(result));
14647 return resultobj;
14648 fail:
14649 return NULL;
14650 }
14651
14652
14653 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14654 PyObject *resultobj = 0;
14655 wxJoystick *arg1 = (wxJoystick *) 0 ;
14656 int result;
14657 void *argp1 = 0 ;
14658 int res1 = 0 ;
14659 PyObject *swig_obj[1] ;
14660
14661 if (!args) SWIG_fail;
14662 swig_obj[0] = args;
14663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14664 if (!SWIG_IsOK(res1)) {
14665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14666 }
14667 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14668 {
14669 PyThreadState* __tstate = wxPyBeginAllowThreads();
14670 result = (int)(arg1)->GetYMax();
14671 wxPyEndAllowThreads(__tstate);
14672 if (PyErr_Occurred()) SWIG_fail;
14673 }
14674 resultobj = SWIG_From_int(static_cast< int >(result));
14675 return resultobj;
14676 fail:
14677 return NULL;
14678 }
14679
14680
14681 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14682 PyObject *resultobj = 0;
14683 wxJoystick *arg1 = (wxJoystick *) 0 ;
14684 int result;
14685 void *argp1 = 0 ;
14686 int res1 = 0 ;
14687 PyObject *swig_obj[1] ;
14688
14689 if (!args) SWIG_fail;
14690 swig_obj[0] = args;
14691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14692 if (!SWIG_IsOK(res1)) {
14693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14694 }
14695 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14696 {
14697 PyThreadState* __tstate = wxPyBeginAllowThreads();
14698 result = (int)(arg1)->GetZMax();
14699 wxPyEndAllowThreads(__tstate);
14700 if (PyErr_Occurred()) SWIG_fail;
14701 }
14702 resultobj = SWIG_From_int(static_cast< int >(result));
14703 return resultobj;
14704 fail:
14705 return NULL;
14706 }
14707
14708
14709 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14710 PyObject *resultobj = 0;
14711 wxJoystick *arg1 = (wxJoystick *) 0 ;
14712 int result;
14713 void *argp1 = 0 ;
14714 int res1 = 0 ;
14715 PyObject *swig_obj[1] ;
14716
14717 if (!args) SWIG_fail;
14718 swig_obj[0] = args;
14719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14720 if (!SWIG_IsOK(res1)) {
14721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14722 }
14723 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (int)(arg1)->GetNumberButtons();
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 resultobj = SWIG_From_int(static_cast< int >(result));
14731 return resultobj;
14732 fail:
14733 return NULL;
14734 }
14735
14736
14737 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14738 PyObject *resultobj = 0;
14739 wxJoystick *arg1 = (wxJoystick *) 0 ;
14740 int result;
14741 void *argp1 = 0 ;
14742 int res1 = 0 ;
14743 PyObject *swig_obj[1] ;
14744
14745 if (!args) SWIG_fail;
14746 swig_obj[0] = args;
14747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14748 if (!SWIG_IsOK(res1)) {
14749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14750 }
14751 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14752 {
14753 PyThreadState* __tstate = wxPyBeginAllowThreads();
14754 result = (int)(arg1)->GetNumberAxes();
14755 wxPyEndAllowThreads(__tstate);
14756 if (PyErr_Occurred()) SWIG_fail;
14757 }
14758 resultobj = SWIG_From_int(static_cast< int >(result));
14759 return resultobj;
14760 fail:
14761 return NULL;
14762 }
14763
14764
14765 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14766 PyObject *resultobj = 0;
14767 wxJoystick *arg1 = (wxJoystick *) 0 ;
14768 int result;
14769 void *argp1 = 0 ;
14770 int res1 = 0 ;
14771 PyObject *swig_obj[1] ;
14772
14773 if (!args) SWIG_fail;
14774 swig_obj[0] = args;
14775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14776 if (!SWIG_IsOK(res1)) {
14777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14778 }
14779 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 result = (int)(arg1)->GetMaxButtons();
14783 wxPyEndAllowThreads(__tstate);
14784 if (PyErr_Occurred()) SWIG_fail;
14785 }
14786 resultobj = SWIG_From_int(static_cast< int >(result));
14787 return resultobj;
14788 fail:
14789 return NULL;
14790 }
14791
14792
14793 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14794 PyObject *resultobj = 0;
14795 wxJoystick *arg1 = (wxJoystick *) 0 ;
14796 int result;
14797 void *argp1 = 0 ;
14798 int res1 = 0 ;
14799 PyObject *swig_obj[1] ;
14800
14801 if (!args) SWIG_fail;
14802 swig_obj[0] = args;
14803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14804 if (!SWIG_IsOK(res1)) {
14805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14806 }
14807 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14808 {
14809 PyThreadState* __tstate = wxPyBeginAllowThreads();
14810 result = (int)(arg1)->GetMaxAxes();
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 resultobj = SWIG_From_int(static_cast< int >(result));
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14822 PyObject *resultobj = 0;
14823 wxJoystick *arg1 = (wxJoystick *) 0 ;
14824 int result;
14825 void *argp1 = 0 ;
14826 int res1 = 0 ;
14827 PyObject *swig_obj[1] ;
14828
14829 if (!args) SWIG_fail;
14830 swig_obj[0] = args;
14831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14832 if (!SWIG_IsOK(res1)) {
14833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14834 }
14835 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 result = (int)(arg1)->GetPollingMin();
14839 wxPyEndAllowThreads(__tstate);
14840 if (PyErr_Occurred()) SWIG_fail;
14841 }
14842 resultobj = SWIG_From_int(static_cast< int >(result));
14843 return resultobj;
14844 fail:
14845 return NULL;
14846 }
14847
14848
14849 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14850 PyObject *resultobj = 0;
14851 wxJoystick *arg1 = (wxJoystick *) 0 ;
14852 int result;
14853 void *argp1 = 0 ;
14854 int res1 = 0 ;
14855 PyObject *swig_obj[1] ;
14856
14857 if (!args) SWIG_fail;
14858 swig_obj[0] = args;
14859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14860 if (!SWIG_IsOK(res1)) {
14861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14862 }
14863 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14864 {
14865 PyThreadState* __tstate = wxPyBeginAllowThreads();
14866 result = (int)(arg1)->GetPollingMax();
14867 wxPyEndAllowThreads(__tstate);
14868 if (PyErr_Occurred()) SWIG_fail;
14869 }
14870 resultobj = SWIG_From_int(static_cast< int >(result));
14871 return resultobj;
14872 fail:
14873 return NULL;
14874 }
14875
14876
14877 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14878 PyObject *resultobj = 0;
14879 wxJoystick *arg1 = (wxJoystick *) 0 ;
14880 int result;
14881 void *argp1 = 0 ;
14882 int res1 = 0 ;
14883 PyObject *swig_obj[1] ;
14884
14885 if (!args) SWIG_fail;
14886 swig_obj[0] = args;
14887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14888 if (!SWIG_IsOK(res1)) {
14889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14890 }
14891 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14892 {
14893 PyThreadState* __tstate = wxPyBeginAllowThreads();
14894 result = (int)(arg1)->GetRudderMin();
14895 wxPyEndAllowThreads(__tstate);
14896 if (PyErr_Occurred()) SWIG_fail;
14897 }
14898 resultobj = SWIG_From_int(static_cast< int >(result));
14899 return resultobj;
14900 fail:
14901 return NULL;
14902 }
14903
14904
14905 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14906 PyObject *resultobj = 0;
14907 wxJoystick *arg1 = (wxJoystick *) 0 ;
14908 int result;
14909 void *argp1 = 0 ;
14910 int res1 = 0 ;
14911 PyObject *swig_obj[1] ;
14912
14913 if (!args) SWIG_fail;
14914 swig_obj[0] = args;
14915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14916 if (!SWIG_IsOK(res1)) {
14917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14918 }
14919 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14920 {
14921 PyThreadState* __tstate = wxPyBeginAllowThreads();
14922 result = (int)(arg1)->GetRudderMax();
14923 wxPyEndAllowThreads(__tstate);
14924 if (PyErr_Occurred()) SWIG_fail;
14925 }
14926 resultobj = SWIG_From_int(static_cast< int >(result));
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14934 PyObject *resultobj = 0;
14935 wxJoystick *arg1 = (wxJoystick *) 0 ;
14936 int result;
14937 void *argp1 = 0 ;
14938 int res1 = 0 ;
14939 PyObject *swig_obj[1] ;
14940
14941 if (!args) SWIG_fail;
14942 swig_obj[0] = args;
14943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14944 if (!SWIG_IsOK(res1)) {
14945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14946 }
14947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (int)(arg1)->GetUMin();
14951 wxPyEndAllowThreads(__tstate);
14952 if (PyErr_Occurred()) SWIG_fail;
14953 }
14954 resultobj = SWIG_From_int(static_cast< int >(result));
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14962 PyObject *resultobj = 0;
14963 wxJoystick *arg1 = (wxJoystick *) 0 ;
14964 int result;
14965 void *argp1 = 0 ;
14966 int res1 = 0 ;
14967 PyObject *swig_obj[1] ;
14968
14969 if (!args) SWIG_fail;
14970 swig_obj[0] = args;
14971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14972 if (!SWIG_IsOK(res1)) {
14973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14974 }
14975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (int)(arg1)->GetUMax();
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 resultobj = SWIG_From_int(static_cast< int >(result));
14983 return resultobj;
14984 fail:
14985 return NULL;
14986 }
14987
14988
14989 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14990 PyObject *resultobj = 0;
14991 wxJoystick *arg1 = (wxJoystick *) 0 ;
14992 int result;
14993 void *argp1 = 0 ;
14994 int res1 = 0 ;
14995 PyObject *swig_obj[1] ;
14996
14997 if (!args) SWIG_fail;
14998 swig_obj[0] = args;
14999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15000 if (!SWIG_IsOK(res1)) {
15001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15002 }
15003 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15004 {
15005 PyThreadState* __tstate = wxPyBeginAllowThreads();
15006 result = (int)(arg1)->GetVMin();
15007 wxPyEndAllowThreads(__tstate);
15008 if (PyErr_Occurred()) SWIG_fail;
15009 }
15010 resultobj = SWIG_From_int(static_cast< int >(result));
15011 return resultobj;
15012 fail:
15013 return NULL;
15014 }
15015
15016
15017 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15018 PyObject *resultobj = 0;
15019 wxJoystick *arg1 = (wxJoystick *) 0 ;
15020 int result;
15021 void *argp1 = 0 ;
15022 int res1 = 0 ;
15023 PyObject *swig_obj[1] ;
15024
15025 if (!args) SWIG_fail;
15026 swig_obj[0] = args;
15027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15028 if (!SWIG_IsOK(res1)) {
15029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15030 }
15031 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 result = (int)(arg1)->GetVMax();
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 resultobj = SWIG_From_int(static_cast< int >(result));
15039 return resultobj;
15040 fail:
15041 return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15046 PyObject *resultobj = 0;
15047 wxJoystick *arg1 = (wxJoystick *) 0 ;
15048 bool result;
15049 void *argp1 = 0 ;
15050 int res1 = 0 ;
15051 PyObject *swig_obj[1] ;
15052
15053 if (!args) SWIG_fail;
15054 swig_obj[0] = args;
15055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15056 if (!SWIG_IsOK(res1)) {
15057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
15058 }
15059 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 result = (bool)(arg1)->HasRudder();
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 {
15067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15068 }
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15076 PyObject *resultobj = 0;
15077 wxJoystick *arg1 = (wxJoystick *) 0 ;
15078 bool result;
15079 void *argp1 = 0 ;
15080 int res1 = 0 ;
15081 PyObject *swig_obj[1] ;
15082
15083 if (!args) SWIG_fail;
15084 swig_obj[0] = args;
15085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
15088 }
15089 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (bool)(arg1)->HasZ();
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 {
15097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15098 }
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15106 PyObject *resultobj = 0;
15107 wxJoystick *arg1 = (wxJoystick *) 0 ;
15108 bool result;
15109 void *argp1 = 0 ;
15110 int res1 = 0 ;
15111 PyObject *swig_obj[1] ;
15112
15113 if (!args) SWIG_fail;
15114 swig_obj[0] = args;
15115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15116 if (!SWIG_IsOK(res1)) {
15117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
15118 }
15119 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 result = (bool)(arg1)->HasU();
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 {
15127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15128 }
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15136 PyObject *resultobj = 0;
15137 wxJoystick *arg1 = (wxJoystick *) 0 ;
15138 bool result;
15139 void *argp1 = 0 ;
15140 int res1 = 0 ;
15141 PyObject *swig_obj[1] ;
15142
15143 if (!args) SWIG_fail;
15144 swig_obj[0] = args;
15145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15146 if (!SWIG_IsOK(res1)) {
15147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15148 }
15149 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (bool)(arg1)->HasV();
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 {
15157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15158 }
15159 return resultobj;
15160 fail:
15161 return NULL;
15162 }
15163
15164
15165 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15166 PyObject *resultobj = 0;
15167 wxJoystick *arg1 = (wxJoystick *) 0 ;
15168 bool result;
15169 void *argp1 = 0 ;
15170 int res1 = 0 ;
15171 PyObject *swig_obj[1] ;
15172
15173 if (!args) SWIG_fail;
15174 swig_obj[0] = args;
15175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15176 if (!SWIG_IsOK(res1)) {
15177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15178 }
15179 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (bool)(arg1)->HasPOV();
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 {
15187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15188 }
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15196 PyObject *resultobj = 0;
15197 wxJoystick *arg1 = (wxJoystick *) 0 ;
15198 bool result;
15199 void *argp1 = 0 ;
15200 int res1 = 0 ;
15201 PyObject *swig_obj[1] ;
15202
15203 if (!args) SWIG_fail;
15204 swig_obj[0] = args;
15205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15208 }
15209 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15210 {
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 result = (bool)(arg1)->HasPOV4Dir();
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 {
15217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15218 }
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15226 PyObject *resultobj = 0;
15227 wxJoystick *arg1 = (wxJoystick *) 0 ;
15228 bool result;
15229 void *argp1 = 0 ;
15230 int res1 = 0 ;
15231 PyObject *swig_obj[1] ;
15232
15233 if (!args) SWIG_fail;
15234 swig_obj[0] = args;
15235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15236 if (!SWIG_IsOK(res1)) {
15237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15238 }
15239 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 result = (bool)(arg1)->HasPOVCTS();
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 {
15247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15248 }
15249 return resultobj;
15250 fail:
15251 return NULL;
15252 }
15253
15254
15255 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15256 PyObject *resultobj = 0;
15257 wxJoystick *arg1 = (wxJoystick *) 0 ;
15258 wxWindow *arg2 = (wxWindow *) 0 ;
15259 int arg3 = (int) 0 ;
15260 bool result;
15261 void *argp1 = 0 ;
15262 int res1 = 0 ;
15263 void *argp2 = 0 ;
15264 int res2 = 0 ;
15265 int val3 ;
15266 int ecode3 = 0 ;
15267 PyObject * obj0 = 0 ;
15268 PyObject * obj1 = 0 ;
15269 PyObject * obj2 = 0 ;
15270 char * kwnames[] = {
15271 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15272 };
15273
15274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15276 if (!SWIG_IsOK(res1)) {
15277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15278 }
15279 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15281 if (!SWIG_IsOK(res2)) {
15282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15283 }
15284 arg2 = reinterpret_cast< wxWindow * >(argp2);
15285 if (obj2) {
15286 ecode3 = SWIG_AsVal_int(obj2, &val3);
15287 if (!SWIG_IsOK(ecode3)) {
15288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15289 }
15290 arg3 = static_cast< int >(val3);
15291 }
15292 {
15293 PyThreadState* __tstate = wxPyBeginAllowThreads();
15294 result = (bool)(arg1)->SetCapture(arg2,arg3);
15295 wxPyEndAllowThreads(__tstate);
15296 if (PyErr_Occurred()) SWIG_fail;
15297 }
15298 {
15299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15300 }
15301 return resultobj;
15302 fail:
15303 return NULL;
15304 }
15305
15306
15307 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15308 PyObject *resultobj = 0;
15309 wxJoystick *arg1 = (wxJoystick *) 0 ;
15310 bool result;
15311 void *argp1 = 0 ;
15312 int res1 = 0 ;
15313 PyObject *swig_obj[1] ;
15314
15315 if (!args) SWIG_fail;
15316 swig_obj[0] = args;
15317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15318 if (!SWIG_IsOK(res1)) {
15319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15320 }
15321 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15322 {
15323 PyThreadState* __tstate = wxPyBeginAllowThreads();
15324 result = (bool)(arg1)->ReleaseCapture();
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 {
15329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15330 }
15331 return resultobj;
15332 fail:
15333 return NULL;
15334 }
15335
15336
15337 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15338 PyObject *obj;
15339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15340 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15341 return SWIG_Py_Void();
15342 }
15343
15344 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15345 return SWIG_Python_InitShadowInstance(args);
15346 }
15347
15348 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15349 PyObject *resultobj = 0;
15350 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15351 int arg2 = (int) 0 ;
15352 int arg3 = (int) wxJOYSTICK1 ;
15353 int arg4 = (int) 0 ;
15354 wxJoystickEvent *result = 0 ;
15355 int val1 ;
15356 int ecode1 = 0 ;
15357 int val2 ;
15358 int ecode2 = 0 ;
15359 int val3 ;
15360 int ecode3 = 0 ;
15361 int val4 ;
15362 int ecode4 = 0 ;
15363 PyObject * obj0 = 0 ;
15364 PyObject * obj1 = 0 ;
15365 PyObject * obj2 = 0 ;
15366 PyObject * obj3 = 0 ;
15367 char * kwnames[] = {
15368 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15369 };
15370
15371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15372 if (obj0) {
15373 ecode1 = SWIG_AsVal_int(obj0, &val1);
15374 if (!SWIG_IsOK(ecode1)) {
15375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15376 }
15377 arg1 = static_cast< wxEventType >(val1);
15378 }
15379 if (obj1) {
15380 ecode2 = SWIG_AsVal_int(obj1, &val2);
15381 if (!SWIG_IsOK(ecode2)) {
15382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15383 }
15384 arg2 = static_cast< int >(val2);
15385 }
15386 if (obj2) {
15387 ecode3 = SWIG_AsVal_int(obj2, &val3);
15388 if (!SWIG_IsOK(ecode3)) {
15389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15390 }
15391 arg3 = static_cast< int >(val3);
15392 }
15393 if (obj3) {
15394 ecode4 = SWIG_AsVal_int(obj3, &val4);
15395 if (!SWIG_IsOK(ecode4)) {
15396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15397 }
15398 arg4 = static_cast< int >(val4);
15399 }
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15414 PyObject *resultobj = 0;
15415 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15416 wxPoint result;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 PyObject *swig_obj[1] ;
15420
15421 if (!args) SWIG_fail;
15422 swig_obj[0] = args;
15423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15426 }
15427 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15442 PyObject *resultobj = 0;
15443 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15444 int result;
15445 void *argp1 = 0 ;
15446 int res1 = 0 ;
15447 PyObject *swig_obj[1] ;
15448
15449 if (!args) SWIG_fail;
15450 swig_obj[0] = args;
15451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15452 if (!SWIG_IsOK(res1)) {
15453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15454 }
15455 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15456 {
15457 PyThreadState* __tstate = wxPyBeginAllowThreads();
15458 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15459 wxPyEndAllowThreads(__tstate);
15460 if (PyErr_Occurred()) SWIG_fail;
15461 }
15462 resultobj = SWIG_From_int(static_cast< int >(result));
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15470 PyObject *resultobj = 0;
15471 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15472 int result;
15473 void *argp1 = 0 ;
15474 int res1 = 0 ;
15475 PyObject *swig_obj[1] ;
15476
15477 if (!args) SWIG_fail;
15478 swig_obj[0] = args;
15479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15480 if (!SWIG_IsOK(res1)) {
15481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15482 }
15483 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15484 {
15485 PyThreadState* __tstate = wxPyBeginAllowThreads();
15486 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 resultobj = SWIG_From_int(static_cast< int >(result));
15491 return resultobj;
15492 fail:
15493 return NULL;
15494 }
15495
15496
15497 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15498 PyObject *resultobj = 0;
15499 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15500 int result;
15501 void *argp1 = 0 ;
15502 int res1 = 0 ;
15503 PyObject *swig_obj[1] ;
15504
15505 if (!args) SWIG_fail;
15506 swig_obj[0] = args;
15507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15508 if (!SWIG_IsOK(res1)) {
15509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15510 }
15511 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_From_int(static_cast< int >(result));
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15526 PyObject *resultobj = 0;
15527 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15528 int result;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 PyObject *swig_obj[1] ;
15532
15533 if (!args) SWIG_fail;
15534 swig_obj[0] = args;
15535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15536 if (!SWIG_IsOK(res1)) {
15537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15538 }
15539 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15540 {
15541 PyThreadState* __tstate = wxPyBeginAllowThreads();
15542 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 resultobj = SWIG_From_int(static_cast< int >(result));
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj = 0;
15555 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15556 int arg2 ;
15557 void *argp1 = 0 ;
15558 int res1 = 0 ;
15559 int val2 ;
15560 int ecode2 = 0 ;
15561 PyObject * obj0 = 0 ;
15562 PyObject * obj1 = 0 ;
15563 char * kwnames[] = {
15564 (char *) "self",(char *) "stick", NULL
15565 };
15566
15567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15569 if (!SWIG_IsOK(res1)) {
15570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15571 }
15572 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15573 ecode2 = SWIG_AsVal_int(obj1, &val2);
15574 if (!SWIG_IsOK(ecode2)) {
15575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15576 }
15577 arg2 = static_cast< int >(val2);
15578 {
15579 PyThreadState* __tstate = wxPyBeginAllowThreads();
15580 (arg1)->SetJoystick(arg2);
15581 wxPyEndAllowThreads(__tstate);
15582 if (PyErr_Occurred()) SWIG_fail;
15583 }
15584 resultobj = SWIG_Py_Void();
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15592 PyObject *resultobj = 0;
15593 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15594 int arg2 ;
15595 void *argp1 = 0 ;
15596 int res1 = 0 ;
15597 int val2 ;
15598 int ecode2 = 0 ;
15599 PyObject * obj0 = 0 ;
15600 PyObject * obj1 = 0 ;
15601 char * kwnames[] = {
15602 (char *) "self",(char *) "state", NULL
15603 };
15604
15605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15607 if (!SWIG_IsOK(res1)) {
15608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15609 }
15610 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15611 ecode2 = SWIG_AsVal_int(obj1, &val2);
15612 if (!SWIG_IsOK(ecode2)) {
15613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15614 }
15615 arg2 = static_cast< int >(val2);
15616 {
15617 PyThreadState* __tstate = wxPyBeginAllowThreads();
15618 (arg1)->SetButtonState(arg2);
15619 wxPyEndAllowThreads(__tstate);
15620 if (PyErr_Occurred()) SWIG_fail;
15621 }
15622 resultobj = SWIG_Py_Void();
15623 return resultobj;
15624 fail:
15625 return NULL;
15626 }
15627
15628
15629 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15630 PyObject *resultobj = 0;
15631 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15632 int arg2 ;
15633 void *argp1 = 0 ;
15634 int res1 = 0 ;
15635 int val2 ;
15636 int ecode2 = 0 ;
15637 PyObject * obj0 = 0 ;
15638 PyObject * obj1 = 0 ;
15639 char * kwnames[] = {
15640 (char *) "self",(char *) "change", NULL
15641 };
15642
15643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15645 if (!SWIG_IsOK(res1)) {
15646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15647 }
15648 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15649 ecode2 = SWIG_AsVal_int(obj1, &val2);
15650 if (!SWIG_IsOK(ecode2)) {
15651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15652 }
15653 arg2 = static_cast< int >(val2);
15654 {
15655 PyThreadState* __tstate = wxPyBeginAllowThreads();
15656 (arg1)->SetButtonChange(arg2);
15657 wxPyEndAllowThreads(__tstate);
15658 if (PyErr_Occurred()) SWIG_fail;
15659 }
15660 resultobj = SWIG_Py_Void();
15661 return resultobj;
15662 fail:
15663 return NULL;
15664 }
15665
15666
15667 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15668 PyObject *resultobj = 0;
15669 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15670 wxPoint *arg2 = 0 ;
15671 void *argp1 = 0 ;
15672 int res1 = 0 ;
15673 wxPoint temp2 ;
15674 PyObject * obj0 = 0 ;
15675 PyObject * obj1 = 0 ;
15676 char * kwnames[] = {
15677 (char *) "self",(char *) "pos", NULL
15678 };
15679
15680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15682 if (!SWIG_IsOK(res1)) {
15683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15684 }
15685 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15686 {
15687 arg2 = &temp2;
15688 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15689 }
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 (arg1)->SetPosition((wxPoint const &)*arg2);
15693 wxPyEndAllowThreads(__tstate);
15694 if (PyErr_Occurred()) SWIG_fail;
15695 }
15696 resultobj = SWIG_Py_Void();
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15704 PyObject *resultobj = 0;
15705 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15706 int arg2 ;
15707 void *argp1 = 0 ;
15708 int res1 = 0 ;
15709 int val2 ;
15710 int ecode2 = 0 ;
15711 PyObject * obj0 = 0 ;
15712 PyObject * obj1 = 0 ;
15713 char * kwnames[] = {
15714 (char *) "self",(char *) "zPos", NULL
15715 };
15716
15717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15719 if (!SWIG_IsOK(res1)) {
15720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15721 }
15722 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15723 ecode2 = SWIG_AsVal_int(obj1, &val2);
15724 if (!SWIG_IsOK(ecode2)) {
15725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15726 }
15727 arg2 = static_cast< int >(val2);
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 (arg1)->SetZPosition(arg2);
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 resultobj = SWIG_Py_Void();
15735 return resultobj;
15736 fail:
15737 return NULL;
15738 }
15739
15740
15741 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15742 PyObject *resultobj = 0;
15743 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15744 bool result;
15745 void *argp1 = 0 ;
15746 int res1 = 0 ;
15747 PyObject *swig_obj[1] ;
15748
15749 if (!args) SWIG_fail;
15750 swig_obj[0] = args;
15751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15752 if (!SWIG_IsOK(res1)) {
15753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15754 }
15755 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15756 {
15757 PyThreadState* __tstate = wxPyBeginAllowThreads();
15758 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 {
15763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15764 }
15765 return resultobj;
15766 fail:
15767 return NULL;
15768 }
15769
15770
15771 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15772 PyObject *resultobj = 0;
15773 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15774 bool result;
15775 void *argp1 = 0 ;
15776 int res1 = 0 ;
15777 PyObject *swig_obj[1] ;
15778
15779 if (!args) SWIG_fail;
15780 swig_obj[0] = args;
15781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15782 if (!SWIG_IsOK(res1)) {
15783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15784 }
15785 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15786 {
15787 PyThreadState* __tstate = wxPyBeginAllowThreads();
15788 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15789 wxPyEndAllowThreads(__tstate);
15790 if (PyErr_Occurred()) SWIG_fail;
15791 }
15792 {
15793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15794 }
15795 return resultobj;
15796 fail:
15797 return NULL;
15798 }
15799
15800
15801 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15802 PyObject *resultobj = 0;
15803 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15804 bool result;
15805 void *argp1 = 0 ;
15806 int res1 = 0 ;
15807 PyObject *swig_obj[1] ;
15808
15809 if (!args) SWIG_fail;
15810 swig_obj[0] = args;
15811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15814 }
15815 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 {
15823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15824 }
15825 return resultobj;
15826 fail:
15827 return NULL;
15828 }
15829
15830
15831 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15832 PyObject *resultobj = 0;
15833 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15834 int arg2 = (int) wxJOY_BUTTON_ANY ;
15835 bool result;
15836 void *argp1 = 0 ;
15837 int res1 = 0 ;
15838 int val2 ;
15839 int ecode2 = 0 ;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 char * kwnames[] = {
15843 (char *) "self",(char *) "but", NULL
15844 };
15845
15846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15848 if (!SWIG_IsOK(res1)) {
15849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15850 }
15851 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15852 if (obj1) {
15853 ecode2 = SWIG_AsVal_int(obj1, &val2);
15854 if (!SWIG_IsOK(ecode2)) {
15855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15856 }
15857 arg2 = static_cast< int >(val2);
15858 }
15859 {
15860 PyThreadState* __tstate = wxPyBeginAllowThreads();
15861 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15862 wxPyEndAllowThreads(__tstate);
15863 if (PyErr_Occurred()) SWIG_fail;
15864 }
15865 {
15866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15867 }
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj = 0;
15876 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15877 int arg2 = (int) wxJOY_BUTTON_ANY ;
15878 bool result;
15879 void *argp1 = 0 ;
15880 int res1 = 0 ;
15881 int val2 ;
15882 int ecode2 = 0 ;
15883 PyObject * obj0 = 0 ;
15884 PyObject * obj1 = 0 ;
15885 char * kwnames[] = {
15886 (char *) "self",(char *) "but", NULL
15887 };
15888
15889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15891 if (!SWIG_IsOK(res1)) {
15892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15893 }
15894 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15895 if (obj1) {
15896 ecode2 = SWIG_AsVal_int(obj1, &val2);
15897 if (!SWIG_IsOK(ecode2)) {
15898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15899 }
15900 arg2 = static_cast< int >(val2);
15901 }
15902 {
15903 PyThreadState* __tstate = wxPyBeginAllowThreads();
15904 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 {
15909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15910 }
15911 return resultobj;
15912 fail:
15913 return NULL;
15914 }
15915
15916
15917 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15918 PyObject *resultobj = 0;
15919 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15920 int arg2 = (int) wxJOY_BUTTON_ANY ;
15921 bool result;
15922 void *argp1 = 0 ;
15923 int res1 = 0 ;
15924 int val2 ;
15925 int ecode2 = 0 ;
15926 PyObject * obj0 = 0 ;
15927 PyObject * obj1 = 0 ;
15928 char * kwnames[] = {
15929 (char *) "self",(char *) "but", NULL
15930 };
15931
15932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15934 if (!SWIG_IsOK(res1)) {
15935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15936 }
15937 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15938 if (obj1) {
15939 ecode2 = SWIG_AsVal_int(obj1, &val2);
15940 if (!SWIG_IsOK(ecode2)) {
15941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15942 }
15943 arg2 = static_cast< int >(val2);
15944 }
15945 {
15946 PyThreadState* __tstate = wxPyBeginAllowThreads();
15947 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15948 wxPyEndAllowThreads(__tstate);
15949 if (PyErr_Occurred()) SWIG_fail;
15950 }
15951 {
15952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15953 }
15954 return resultobj;
15955 fail:
15956 return NULL;
15957 }
15958
15959
15960 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15961 PyObject *obj;
15962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15963 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15964 return SWIG_Py_Void();
15965 }
15966
15967 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15968 return SWIG_Python_InitShadowInstance(args);
15969 }
15970
15971 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15972 PyObject *resultobj = 0;
15973 wxString const &arg1_defvalue = wxPyEmptyString ;
15974 wxString *arg1 = (wxString *) &arg1_defvalue ;
15975 wxSound *result = 0 ;
15976 bool temp1 = false ;
15977 PyObject * obj0 = 0 ;
15978 char * kwnames[] = {
15979 (char *) "fileName", NULL
15980 };
15981
15982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15983 if (obj0) {
15984 {
15985 arg1 = wxString_in_helper(obj0);
15986 if (arg1 == NULL) SWIG_fail;
15987 temp1 = true;
15988 }
15989 }
15990 {
15991 if (!wxPyCheckForApp()) SWIG_fail;
15992 PyThreadState* __tstate = wxPyBeginAllowThreads();
15993 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15994 wxPyEndAllowThreads(__tstate);
15995 if (PyErr_Occurred()) SWIG_fail;
15996 }
15997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15998 {
15999 if (temp1)
16000 delete arg1;
16001 }
16002 return resultobj;
16003 fail:
16004 {
16005 if (temp1)
16006 delete arg1;
16007 }
16008 return NULL;
16009 }
16010
16011
16012 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16013 PyObject *resultobj = 0;
16014 PyObject *arg1 = (PyObject *) 0 ;
16015 wxSound *result = 0 ;
16016 PyObject * obj0 = 0 ;
16017 char * kwnames[] = {
16018 (char *) "data", NULL
16019 };
16020
16021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16022 arg1 = obj0;
16023 {
16024 if (!wxPyCheckForApp()) SWIG_fail;
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 result = (wxSound *)new_wxSound(arg1);
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16038 PyObject *resultobj = 0;
16039 wxSound *arg1 = (wxSound *) 0 ;
16040 void *argp1 = 0 ;
16041 int res1 = 0 ;
16042 PyObject *swig_obj[1] ;
16043
16044 if (!args) SWIG_fail;
16045 swig_obj[0] = args;
16046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16047 if (!SWIG_IsOK(res1)) {
16048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16049 }
16050 arg1 = reinterpret_cast< wxSound * >(argp1);
16051 {
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 delete arg1;
16054
16055 wxPyEndAllowThreads(__tstate);
16056 if (PyErr_Occurred()) SWIG_fail;
16057 }
16058 resultobj = SWIG_Py_Void();
16059 return resultobj;
16060 fail:
16061 return NULL;
16062 }
16063
16064
16065 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16066 PyObject *resultobj = 0;
16067 wxSound *arg1 = (wxSound *) 0 ;
16068 wxString *arg2 = 0 ;
16069 bool result;
16070 void *argp1 = 0 ;
16071 int res1 = 0 ;
16072 bool temp2 = false ;
16073 PyObject * obj0 = 0 ;
16074 PyObject * obj1 = 0 ;
16075 char * kwnames[] = {
16076 (char *) "self",(char *) "fileName", NULL
16077 };
16078
16079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
16080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16081 if (!SWIG_IsOK(res1)) {
16082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
16083 }
16084 arg1 = reinterpret_cast< wxSound * >(argp1);
16085 {
16086 arg2 = wxString_in_helper(obj1);
16087 if (arg2 == NULL) SWIG_fail;
16088 temp2 = true;
16089 }
16090 {
16091 PyThreadState* __tstate = wxPyBeginAllowThreads();
16092 result = (bool)(arg1)->Create((wxString const &)*arg2);
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 {
16097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16098 }
16099 {
16100 if (temp2)
16101 delete arg2;
16102 }
16103 return resultobj;
16104 fail:
16105 {
16106 if (temp2)
16107 delete arg2;
16108 }
16109 return NULL;
16110 }
16111
16112
16113 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj = 0;
16115 wxSound *arg1 = (wxSound *) 0 ;
16116 PyObject *arg2 = (PyObject *) 0 ;
16117 bool result;
16118 void *argp1 = 0 ;
16119 int res1 = 0 ;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 char * kwnames[] = {
16123 (char *) "self",(char *) "data", NULL
16124 };
16125
16126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16130 }
16131 arg1 = reinterpret_cast< wxSound * >(argp1);
16132 arg2 = obj1;
16133 {
16134 PyThreadState* __tstate = wxPyBeginAllowThreads();
16135 result = (bool)wxSound_CreateFromData(arg1,arg2);
16136 wxPyEndAllowThreads(__tstate);
16137 if (PyErr_Occurred()) SWIG_fail;
16138 }
16139 {
16140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16141 }
16142 return resultobj;
16143 fail:
16144 return NULL;
16145 }
16146
16147
16148 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16149 PyObject *resultobj = 0;
16150 wxSound *arg1 = (wxSound *) 0 ;
16151 bool result;
16152 void *argp1 = 0 ;
16153 int res1 = 0 ;
16154 PyObject *swig_obj[1] ;
16155
16156 if (!args) SWIG_fail;
16157 swig_obj[0] = args;
16158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16159 if (!SWIG_IsOK(res1)) {
16160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16161 }
16162 arg1 = reinterpret_cast< wxSound * >(argp1);
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 result = (bool)(arg1)->IsOk();
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 {
16170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16171 }
16172 return resultobj;
16173 fail:
16174 return NULL;
16175 }
16176
16177
16178 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16179 PyObject *resultobj = 0;
16180 wxSound *arg1 = (wxSound *) 0 ;
16181 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16182 bool result;
16183 void *argp1 = 0 ;
16184 int res1 = 0 ;
16185 unsigned int val2 ;
16186 int ecode2 = 0 ;
16187 PyObject * obj0 = 0 ;
16188 PyObject * obj1 = 0 ;
16189 char * kwnames[] = {
16190 (char *) "self",(char *) "flags", NULL
16191 };
16192
16193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16195 if (!SWIG_IsOK(res1)) {
16196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16197 }
16198 arg1 = reinterpret_cast< wxSound * >(argp1);
16199 if (obj1) {
16200 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16201 if (!SWIG_IsOK(ecode2)) {
16202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16203 }
16204 arg2 = static_cast< unsigned int >(val2);
16205 }
16206 {
16207 if (!wxPyCheckForApp()) SWIG_fail;
16208 PyThreadState* __tstate = wxPyBeginAllowThreads();
16209 result = (bool)((wxSound const *)arg1)->Play(arg2);
16210 wxPyEndAllowThreads(__tstate);
16211 if (PyErr_Occurred()) SWIG_fail;
16212 }
16213 {
16214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16215 }
16216 return resultobj;
16217 fail:
16218 return NULL;
16219 }
16220
16221
16222 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16223 PyObject *resultobj = 0;
16224 wxString *arg1 = 0 ;
16225 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16226 bool result;
16227 bool temp1 = false ;
16228 unsigned int val2 ;
16229 int ecode2 = 0 ;
16230 PyObject * obj0 = 0 ;
16231 PyObject * obj1 = 0 ;
16232 char * kwnames[] = {
16233 (char *) "filename",(char *) "flags", NULL
16234 };
16235
16236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16237 {
16238 arg1 = wxString_in_helper(obj0);
16239 if (arg1 == NULL) SWIG_fail;
16240 temp1 = true;
16241 }
16242 if (obj1) {
16243 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16244 if (!SWIG_IsOK(ecode2)) {
16245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16246 }
16247 arg2 = static_cast< unsigned int >(val2);
16248 }
16249 {
16250 if (!wxPyCheckForApp()) SWIG_fail;
16251 PyThreadState* __tstate = wxPyBeginAllowThreads();
16252 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 {
16257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16258 }
16259 {
16260 if (temp1)
16261 delete arg1;
16262 }
16263 return resultobj;
16264 fail:
16265 {
16266 if (temp1)
16267 delete arg1;
16268 }
16269 return NULL;
16270 }
16271
16272
16273 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16274 PyObject *resultobj = 0;
16275
16276 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16277 {
16278 if (!wxPyCheckForApp()) SWIG_fail;
16279 PyThreadState* __tstate = wxPyBeginAllowThreads();
16280 wxSound::Stop();
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 resultobj = SWIG_Py_Void();
16285 return resultobj;
16286 fail:
16287 return NULL;
16288 }
16289
16290
16291 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16292 PyObject *obj;
16293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16294 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16295 return SWIG_Py_Void();
16296 }
16297
16298 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16299 return SWIG_Python_InitShadowInstance(args);
16300 }
16301
16302 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16303 PyObject *resultobj = 0;
16304 wxString *arg1 = 0 ;
16305 wxString *arg2 = 0 ;
16306 wxString *arg3 = 0 ;
16307 wxString *arg4 = 0 ;
16308 wxFileTypeInfo *result = 0 ;
16309 bool temp1 = false ;
16310 bool temp2 = false ;
16311 bool temp3 = false ;
16312 bool temp4 = false ;
16313 PyObject * obj0 = 0 ;
16314 PyObject * obj1 = 0 ;
16315 PyObject * obj2 = 0 ;
16316 PyObject * obj3 = 0 ;
16317 char * kwnames[] = {
16318 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16319 };
16320
16321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16322 {
16323 arg1 = wxString_in_helper(obj0);
16324 if (arg1 == NULL) SWIG_fail;
16325 temp1 = true;
16326 }
16327 {
16328 arg2 = wxString_in_helper(obj1);
16329 if (arg2 == NULL) SWIG_fail;
16330 temp2 = true;
16331 }
16332 {
16333 arg3 = wxString_in_helper(obj2);
16334 if (arg3 == NULL) SWIG_fail;
16335 temp3 = true;
16336 }
16337 {
16338 arg4 = wxString_in_helper(obj3);
16339 if (arg4 == NULL) SWIG_fail;
16340 temp4 = true;
16341 }
16342 {
16343 PyThreadState* __tstate = wxPyBeginAllowThreads();
16344 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16345 wxPyEndAllowThreads(__tstate);
16346 if (PyErr_Occurred()) SWIG_fail;
16347 }
16348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16349 {
16350 if (temp1)
16351 delete arg1;
16352 }
16353 {
16354 if (temp2)
16355 delete arg2;
16356 }
16357 {
16358 if (temp3)
16359 delete arg3;
16360 }
16361 {
16362 if (temp4)
16363 delete arg4;
16364 }
16365 return resultobj;
16366 fail:
16367 {
16368 if (temp1)
16369 delete arg1;
16370 }
16371 {
16372 if (temp2)
16373 delete arg2;
16374 }
16375 {
16376 if (temp3)
16377 delete arg3;
16378 }
16379 {
16380 if (temp4)
16381 delete arg4;
16382 }
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16388 PyObject *resultobj = 0;
16389 wxArrayString *arg1 = 0 ;
16390 wxFileTypeInfo *result = 0 ;
16391 bool temp1 = false ;
16392 PyObject * obj0 = 0 ;
16393 char * kwnames[] = {
16394 (char *) "sArray", NULL
16395 };
16396
16397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16398 {
16399 if (! PySequence_Check(obj0)) {
16400 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16401 SWIG_fail;
16402 }
16403 arg1 = new wxArrayString;
16404 temp1 = true;
16405 int i, len=PySequence_Length(obj0);
16406 for (i=0; i<len; i++) {
16407 PyObject* item = PySequence_GetItem(obj0, i);
16408 wxString* s = wxString_in_helper(item);
16409 if (PyErr_Occurred()) SWIG_fail;
16410 arg1->Add(*s);
16411 delete s;
16412 Py_DECREF(item);
16413 }
16414 }
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16418 wxPyEndAllowThreads(__tstate);
16419 if (PyErr_Occurred()) SWIG_fail;
16420 }
16421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16422 {
16423 if (temp1) delete arg1;
16424 }
16425 return resultobj;
16426 fail:
16427 {
16428 if (temp1) delete arg1;
16429 }
16430 return NULL;
16431 }
16432
16433
16434 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16435 PyObject *resultobj = 0;
16436 wxFileTypeInfo *result = 0 ;
16437
16438 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16439 {
16440 PyThreadState* __tstate = wxPyBeginAllowThreads();
16441 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16442 wxPyEndAllowThreads(__tstate);
16443 if (PyErr_Occurred()) SWIG_fail;
16444 }
16445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16446 return resultobj;
16447 fail:
16448 return NULL;
16449 }
16450
16451
16452 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16453 PyObject *resultobj = 0;
16454 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16455 bool result;
16456 void *argp1 = 0 ;
16457 int res1 = 0 ;
16458 PyObject *swig_obj[1] ;
16459
16460 if (!args) SWIG_fail;
16461 swig_obj[0] = args;
16462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16463 if (!SWIG_IsOK(res1)) {
16464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16465 }
16466 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16467 {
16468 PyThreadState* __tstate = wxPyBeginAllowThreads();
16469 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16470 wxPyEndAllowThreads(__tstate);
16471 if (PyErr_Occurred()) SWIG_fail;
16472 }
16473 {
16474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16475 }
16476 return resultobj;
16477 fail:
16478 return NULL;
16479 }
16480
16481
16482 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16483 PyObject *resultobj = 0;
16484 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16485 wxString *arg2 = 0 ;
16486 int arg3 = (int) 0 ;
16487 void *argp1 = 0 ;
16488 int res1 = 0 ;
16489 bool temp2 = false ;
16490 int val3 ;
16491 int ecode3 = 0 ;
16492 PyObject * obj0 = 0 ;
16493 PyObject * obj1 = 0 ;
16494 PyObject * obj2 = 0 ;
16495 char * kwnames[] = {
16496 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16497 };
16498
16499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16501 if (!SWIG_IsOK(res1)) {
16502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16503 }
16504 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16505 {
16506 arg2 = wxString_in_helper(obj1);
16507 if (arg2 == NULL) SWIG_fail;
16508 temp2 = true;
16509 }
16510 if (obj2) {
16511 ecode3 = SWIG_AsVal_int(obj2, &val3);
16512 if (!SWIG_IsOK(ecode3)) {
16513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16514 }
16515 arg3 = static_cast< int >(val3);
16516 }
16517 {
16518 PyThreadState* __tstate = wxPyBeginAllowThreads();
16519 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16520 wxPyEndAllowThreads(__tstate);
16521 if (PyErr_Occurred()) SWIG_fail;
16522 }
16523 resultobj = SWIG_Py_Void();
16524 {
16525 if (temp2)
16526 delete arg2;
16527 }
16528 return resultobj;
16529 fail:
16530 {
16531 if (temp2)
16532 delete arg2;
16533 }
16534 return NULL;
16535 }
16536
16537
16538 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16539 PyObject *resultobj = 0;
16540 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16541 wxString *arg2 = 0 ;
16542 void *argp1 = 0 ;
16543 int res1 = 0 ;
16544 bool temp2 = false ;
16545 PyObject * obj0 = 0 ;
16546 PyObject * obj1 = 0 ;
16547 char * kwnames[] = {
16548 (char *) "self",(char *) "shortDesc", NULL
16549 };
16550
16551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16553 if (!SWIG_IsOK(res1)) {
16554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16555 }
16556 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16557 {
16558 arg2 = wxString_in_helper(obj1);
16559 if (arg2 == NULL) SWIG_fail;
16560 temp2 = true;
16561 }
16562 {
16563 PyThreadState* __tstate = wxPyBeginAllowThreads();
16564 (arg1)->SetShortDesc((wxString const &)*arg2);
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 resultobj = SWIG_Py_Void();
16569 {
16570 if (temp2)
16571 delete arg2;
16572 }
16573 return resultobj;
16574 fail:
16575 {
16576 if (temp2)
16577 delete arg2;
16578 }
16579 return NULL;
16580 }
16581
16582
16583 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16584 PyObject *resultobj = 0;
16585 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16586 wxString *result = 0 ;
16587 void *argp1 = 0 ;
16588 int res1 = 0 ;
16589 PyObject *swig_obj[1] ;
16590
16591 if (!args) SWIG_fail;
16592 swig_obj[0] = args;
16593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16594 if (!SWIG_IsOK(res1)) {
16595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16596 }
16597 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16598 {
16599 PyThreadState* __tstate = wxPyBeginAllowThreads();
16600 {
16601 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16602 result = (wxString *) &_result_ref;
16603 }
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 {
16608 #if wxUSE_UNICODE
16609 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16610 #else
16611 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16612 #endif
16613 }
16614 return resultobj;
16615 fail:
16616 return NULL;
16617 }
16618
16619
16620 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16621 PyObject *resultobj = 0;
16622 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16623 wxString *result = 0 ;
16624 void *argp1 = 0 ;
16625 int res1 = 0 ;
16626 PyObject *swig_obj[1] ;
16627
16628 if (!args) SWIG_fail;
16629 swig_obj[0] = args;
16630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16631 if (!SWIG_IsOK(res1)) {
16632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16633 }
16634 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16635 {
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 {
16638 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16639 result = (wxString *) &_result_ref;
16640 }
16641 wxPyEndAllowThreads(__tstate);
16642 if (PyErr_Occurred()) SWIG_fail;
16643 }
16644 {
16645 #if wxUSE_UNICODE
16646 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16647 #else
16648 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16649 #endif
16650 }
16651 return resultobj;
16652 fail:
16653 return NULL;
16654 }
16655
16656
16657 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16658 PyObject *resultobj = 0;
16659 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16660 wxString *result = 0 ;
16661 void *argp1 = 0 ;
16662 int res1 = 0 ;
16663 PyObject *swig_obj[1] ;
16664
16665 if (!args) SWIG_fail;
16666 swig_obj[0] = args;
16667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16668 if (!SWIG_IsOK(res1)) {
16669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16670 }
16671 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 {
16675 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16676 result = (wxString *) &_result_ref;
16677 }
16678 wxPyEndAllowThreads(__tstate);
16679 if (PyErr_Occurred()) SWIG_fail;
16680 }
16681 {
16682 #if wxUSE_UNICODE
16683 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16684 #else
16685 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16686 #endif
16687 }
16688 return resultobj;
16689 fail:
16690 return NULL;
16691 }
16692
16693
16694 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16695 PyObject *resultobj = 0;
16696 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16697 wxString *result = 0 ;
16698 void *argp1 = 0 ;
16699 int res1 = 0 ;
16700 PyObject *swig_obj[1] ;
16701
16702 if (!args) SWIG_fail;
16703 swig_obj[0] = args;
16704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16705 if (!SWIG_IsOK(res1)) {
16706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16707 }
16708 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 {
16712 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16713 result = (wxString *) &_result_ref;
16714 }
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 {
16719 #if wxUSE_UNICODE
16720 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16721 #else
16722 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16723 #endif
16724 }
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16732 PyObject *resultobj = 0;
16733 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16734 wxString *result = 0 ;
16735 void *argp1 = 0 ;
16736 int res1 = 0 ;
16737 PyObject *swig_obj[1] ;
16738
16739 if (!args) SWIG_fail;
16740 swig_obj[0] = args;
16741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16742 if (!SWIG_IsOK(res1)) {
16743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16744 }
16745 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16746 {
16747 PyThreadState* __tstate = wxPyBeginAllowThreads();
16748 {
16749 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16750 result = (wxString *) &_result_ref;
16751 }
16752 wxPyEndAllowThreads(__tstate);
16753 if (PyErr_Occurred()) SWIG_fail;
16754 }
16755 {
16756 #if wxUSE_UNICODE
16757 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16758 #else
16759 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16760 #endif
16761 }
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16769 PyObject *resultobj = 0;
16770 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16771 wxArrayString *result = 0 ;
16772 void *argp1 = 0 ;
16773 int res1 = 0 ;
16774 PyObject *swig_obj[1] ;
16775
16776 if (!args) SWIG_fail;
16777 swig_obj[0] = args;
16778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16779 if (!SWIG_IsOK(res1)) {
16780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16781 }
16782 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 {
16786 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16787 result = (wxArrayString *) &_result_ref;
16788 }
16789 wxPyEndAllowThreads(__tstate);
16790 if (PyErr_Occurred()) SWIG_fail;
16791 }
16792 {
16793 resultobj = wxArrayString2PyList_helper(*result);
16794 }
16795 return resultobj;
16796 fail:
16797 return NULL;
16798 }
16799
16800
16801 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16802 PyObject *resultobj = 0;
16803 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16804 size_t result;
16805 void *argp1 = 0 ;
16806 int res1 = 0 ;
16807 PyObject *swig_obj[1] ;
16808
16809 if (!args) SWIG_fail;
16810 swig_obj[0] = args;
16811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16812 if (!SWIG_IsOK(res1)) {
16813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16814 }
16815 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16816 {
16817 PyThreadState* __tstate = wxPyBeginAllowThreads();
16818 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16819 wxPyEndAllowThreads(__tstate);
16820 if (PyErr_Occurred()) SWIG_fail;
16821 }
16822 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16823 return resultobj;
16824 fail:
16825 return NULL;
16826 }
16827
16828
16829 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16830 PyObject *resultobj = 0;
16831 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16832 wxString *result = 0 ;
16833 void *argp1 = 0 ;
16834 int res1 = 0 ;
16835 PyObject *swig_obj[1] ;
16836
16837 if (!args) SWIG_fail;
16838 swig_obj[0] = args;
16839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16840 if (!SWIG_IsOK(res1)) {
16841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16842 }
16843 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16844 {
16845 PyThreadState* __tstate = wxPyBeginAllowThreads();
16846 {
16847 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16848 result = (wxString *) &_result_ref;
16849 }
16850 wxPyEndAllowThreads(__tstate);
16851 if (PyErr_Occurred()) SWIG_fail;
16852 }
16853 {
16854 #if wxUSE_UNICODE
16855 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16856 #else
16857 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16858 #endif
16859 }
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16867 PyObject *resultobj = 0;
16868 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16869 int result;
16870 void *argp1 = 0 ;
16871 int res1 = 0 ;
16872 PyObject *swig_obj[1] ;
16873
16874 if (!args) SWIG_fail;
16875 swig_obj[0] = args;
16876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16877 if (!SWIG_IsOK(res1)) {
16878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16879 }
16880 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 resultobj = SWIG_From_int(static_cast< int >(result));
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16895 PyObject *obj;
16896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16897 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16898 return SWIG_Py_Void();
16899 }
16900
16901 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16902 return SWIG_Python_InitShadowInstance(args);
16903 }
16904
16905 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16906 PyObject *resultobj = 0;
16907 wxFileTypeInfo *arg1 = 0 ;
16908 wxFileType *result = 0 ;
16909 void *argp1 = 0 ;
16910 int res1 = 0 ;
16911 PyObject * obj0 = 0 ;
16912 char * kwnames[] = {
16913 (char *) "ftInfo", NULL
16914 };
16915
16916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16917 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16918 if (!SWIG_IsOK(res1)) {
16919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16920 }
16921 if (!argp1) {
16922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16923 }
16924 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16932 return resultobj;
16933 fail:
16934 return NULL;
16935 }
16936
16937
16938 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16939 PyObject *resultobj = 0;
16940 wxFileType *arg1 = (wxFileType *) 0 ;
16941 void *argp1 = 0 ;
16942 int res1 = 0 ;
16943 PyObject *swig_obj[1] ;
16944
16945 if (!args) SWIG_fail;
16946 swig_obj[0] = args;
16947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16948 if (!SWIG_IsOK(res1)) {
16949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16950 }
16951 arg1 = reinterpret_cast< wxFileType * >(argp1);
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 delete arg1;
16955
16956 wxPyEndAllowThreads(__tstate);
16957 if (PyErr_Occurred()) SWIG_fail;
16958 }
16959 resultobj = SWIG_Py_Void();
16960 return resultobj;
16961 fail:
16962 return NULL;
16963 }
16964
16965
16966 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16967 PyObject *resultobj = 0;
16968 wxFileType *arg1 = (wxFileType *) 0 ;
16969 PyObject *result = 0 ;
16970 void *argp1 = 0 ;
16971 int res1 = 0 ;
16972 PyObject *swig_obj[1] ;
16973
16974 if (!args) SWIG_fail;
16975 swig_obj[0] = args;
16976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16977 if (!SWIG_IsOK(res1)) {
16978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16979 }
16980 arg1 = reinterpret_cast< wxFileType * >(argp1);
16981 {
16982 PyThreadState* __tstate = wxPyBeginAllowThreads();
16983 result = (PyObject *)wxFileType_GetMimeType(arg1);
16984 wxPyEndAllowThreads(__tstate);
16985 if (PyErr_Occurred()) SWIG_fail;
16986 }
16987 resultobj = result;
16988 return resultobj;
16989 fail:
16990 return NULL;
16991 }
16992
16993
16994 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16995 PyObject *resultobj = 0;
16996 wxFileType *arg1 = (wxFileType *) 0 ;
16997 PyObject *result = 0 ;
16998 void *argp1 = 0 ;
16999 int res1 = 0 ;
17000 PyObject *swig_obj[1] ;
17001
17002 if (!args) SWIG_fail;
17003 swig_obj[0] = args;
17004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17005 if (!SWIG_IsOK(res1)) {
17006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17007 }
17008 arg1 = reinterpret_cast< wxFileType * >(argp1);
17009 {
17010 PyThreadState* __tstate = wxPyBeginAllowThreads();
17011 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17012 wxPyEndAllowThreads(__tstate);
17013 if (PyErr_Occurred()) SWIG_fail;
17014 }
17015 resultobj = result;
17016 return resultobj;
17017 fail:
17018 return NULL;
17019 }
17020
17021
17022 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17023 PyObject *resultobj = 0;
17024 wxFileType *arg1 = (wxFileType *) 0 ;
17025 PyObject *result = 0 ;
17026 void *argp1 = 0 ;
17027 int res1 = 0 ;
17028 PyObject *swig_obj[1] ;
17029
17030 if (!args) SWIG_fail;
17031 swig_obj[0] = args;
17032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17033 if (!SWIG_IsOK(res1)) {
17034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17035 }
17036 arg1 = reinterpret_cast< wxFileType * >(argp1);
17037 {
17038 PyThreadState* __tstate = wxPyBeginAllowThreads();
17039 result = (PyObject *)wxFileType_GetExtensions(arg1);
17040 wxPyEndAllowThreads(__tstate);
17041 if (PyErr_Occurred()) SWIG_fail;
17042 }
17043 resultobj = result;
17044 return resultobj;
17045 fail:
17046 return NULL;
17047 }
17048
17049
17050 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17051 PyObject *resultobj = 0;
17052 wxFileType *arg1 = (wxFileType *) 0 ;
17053 wxIcon *result = 0 ;
17054 void *argp1 = 0 ;
17055 int res1 = 0 ;
17056 PyObject *swig_obj[1] ;
17057
17058 if (!args) SWIG_fail;
17059 swig_obj[0] = args;
17060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17061 if (!SWIG_IsOK(res1)) {
17062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17063 }
17064 arg1 = reinterpret_cast< wxFileType * >(argp1);
17065 {
17066 PyThreadState* __tstate = wxPyBeginAllowThreads();
17067 result = (wxIcon *)wxFileType_GetIcon(arg1);
17068 wxPyEndAllowThreads(__tstate);
17069 if (PyErr_Occurred()) SWIG_fail;
17070 }
17071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
17072 return resultobj;
17073 fail:
17074 return NULL;
17075 }
17076
17077
17078 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17079 PyObject *resultobj = 0;
17080 wxFileType *arg1 = (wxFileType *) 0 ;
17081 PyObject *result = 0 ;
17082 void *argp1 = 0 ;
17083 int res1 = 0 ;
17084 PyObject *swig_obj[1] ;
17085
17086 if (!args) SWIG_fail;
17087 swig_obj[0] = args;
17088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17089 if (!SWIG_IsOK(res1)) {
17090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
17091 }
17092 arg1 = reinterpret_cast< wxFileType * >(argp1);
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (PyObject *)wxFileType_GetIconInfo(arg1);
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 resultobj = result;
17100 return resultobj;
17101 fail:
17102 return NULL;
17103 }
17104
17105
17106 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17107 PyObject *resultobj = 0;
17108 wxFileType *arg1 = (wxFileType *) 0 ;
17109 PyObject *result = 0 ;
17110 void *argp1 = 0 ;
17111 int res1 = 0 ;
17112 PyObject *swig_obj[1] ;
17113
17114 if (!args) SWIG_fail;
17115 swig_obj[0] = args;
17116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17117 if (!SWIG_IsOK(res1)) {
17118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17119 }
17120 arg1 = reinterpret_cast< wxFileType * >(argp1);
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (PyObject *)wxFileType_GetDescription(arg1);
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 resultobj = result;
17128 return resultobj;
17129 fail:
17130 return NULL;
17131 }
17132
17133
17134 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17135 PyObject *resultobj = 0;
17136 wxFileType *arg1 = (wxFileType *) 0 ;
17137 wxString *arg2 = 0 ;
17138 wxString const &arg3_defvalue = wxPyEmptyString ;
17139 wxString *arg3 = (wxString *) &arg3_defvalue ;
17140 PyObject *result = 0 ;
17141 void *argp1 = 0 ;
17142 int res1 = 0 ;
17143 bool temp2 = false ;
17144 bool temp3 = false ;
17145 PyObject * obj0 = 0 ;
17146 PyObject * obj1 = 0 ;
17147 PyObject * obj2 = 0 ;
17148 char * kwnames[] = {
17149 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17150 };
17151
17152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17154 if (!SWIG_IsOK(res1)) {
17155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17156 }
17157 arg1 = reinterpret_cast< wxFileType * >(argp1);
17158 {
17159 arg2 = wxString_in_helper(obj1);
17160 if (arg2 == NULL) SWIG_fail;
17161 temp2 = true;
17162 }
17163 if (obj2) {
17164 {
17165 arg3 = wxString_in_helper(obj2);
17166 if (arg3 == NULL) SWIG_fail;
17167 temp3 = true;
17168 }
17169 }
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17173 wxPyEndAllowThreads(__tstate);
17174 if (PyErr_Occurred()) SWIG_fail;
17175 }
17176 resultobj = result;
17177 {
17178 if (temp2)
17179 delete arg2;
17180 }
17181 {
17182 if (temp3)
17183 delete arg3;
17184 }
17185 return resultobj;
17186 fail:
17187 {
17188 if (temp2)
17189 delete arg2;
17190 }
17191 {
17192 if (temp3)
17193 delete arg3;
17194 }
17195 return NULL;
17196 }
17197
17198
17199 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17200 PyObject *resultobj = 0;
17201 wxFileType *arg1 = (wxFileType *) 0 ;
17202 wxString *arg2 = 0 ;
17203 wxString const &arg3_defvalue = wxPyEmptyString ;
17204 wxString *arg3 = (wxString *) &arg3_defvalue ;
17205 PyObject *result = 0 ;
17206 void *argp1 = 0 ;
17207 int res1 = 0 ;
17208 bool temp2 = false ;
17209 bool temp3 = false ;
17210 PyObject * obj0 = 0 ;
17211 PyObject * obj1 = 0 ;
17212 PyObject * obj2 = 0 ;
17213 char * kwnames[] = {
17214 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17215 };
17216
17217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17219 if (!SWIG_IsOK(res1)) {
17220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17221 }
17222 arg1 = reinterpret_cast< wxFileType * >(argp1);
17223 {
17224 arg2 = wxString_in_helper(obj1);
17225 if (arg2 == NULL) SWIG_fail;
17226 temp2 = true;
17227 }
17228 if (obj2) {
17229 {
17230 arg3 = wxString_in_helper(obj2);
17231 if (arg3 == NULL) SWIG_fail;
17232 temp3 = true;
17233 }
17234 }
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17238 wxPyEndAllowThreads(__tstate);
17239 if (PyErr_Occurred()) SWIG_fail;
17240 }
17241 resultobj = result;
17242 {
17243 if (temp2)
17244 delete arg2;
17245 }
17246 {
17247 if (temp3)
17248 delete arg3;
17249 }
17250 return resultobj;
17251 fail:
17252 {
17253 if (temp2)
17254 delete arg2;
17255 }
17256 {
17257 if (temp3)
17258 delete arg3;
17259 }
17260 return NULL;
17261 }
17262
17263
17264 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17265 PyObject *resultobj = 0;
17266 wxFileType *arg1 = (wxFileType *) 0 ;
17267 wxString *arg2 = 0 ;
17268 wxString const &arg3_defvalue = wxPyEmptyString ;
17269 wxString *arg3 = (wxString *) &arg3_defvalue ;
17270 PyObject *result = 0 ;
17271 void *argp1 = 0 ;
17272 int res1 = 0 ;
17273 bool temp2 = false ;
17274 bool temp3 = false ;
17275 PyObject * obj0 = 0 ;
17276 PyObject * obj1 = 0 ;
17277 PyObject * obj2 = 0 ;
17278 char * kwnames[] = {
17279 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17280 };
17281
17282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17284 if (!SWIG_IsOK(res1)) {
17285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17286 }
17287 arg1 = reinterpret_cast< wxFileType * >(argp1);
17288 {
17289 arg2 = wxString_in_helper(obj1);
17290 if (arg2 == NULL) SWIG_fail;
17291 temp2 = true;
17292 }
17293 if (obj2) {
17294 {
17295 arg3 = wxString_in_helper(obj2);
17296 if (arg3 == NULL) SWIG_fail;
17297 temp3 = true;
17298 }
17299 }
17300 {
17301 PyThreadState* __tstate = wxPyBeginAllowThreads();
17302 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17303 wxPyEndAllowThreads(__tstate);
17304 if (PyErr_Occurred()) SWIG_fail;
17305 }
17306 resultobj = result;
17307 {
17308 if (temp2)
17309 delete arg2;
17310 }
17311 {
17312 if (temp3)
17313 delete arg3;
17314 }
17315 return resultobj;
17316 fail:
17317 {
17318 if (temp2)
17319 delete arg2;
17320 }
17321 {
17322 if (temp3)
17323 delete arg3;
17324 }
17325 return NULL;
17326 }
17327
17328
17329 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17330 PyObject *resultobj = 0;
17331 wxFileType *arg1 = (wxFileType *) 0 ;
17332 wxString *arg2 = 0 ;
17333 wxString *arg3 = 0 ;
17334 bool arg4 = (bool) true ;
17335 bool result;
17336 void *argp1 = 0 ;
17337 int res1 = 0 ;
17338 bool temp2 = false ;
17339 bool temp3 = false ;
17340 bool val4 ;
17341 int ecode4 = 0 ;
17342 PyObject * obj0 = 0 ;
17343 PyObject * obj1 = 0 ;
17344 PyObject * obj2 = 0 ;
17345 PyObject * obj3 = 0 ;
17346 char * kwnames[] = {
17347 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17348 };
17349
17350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17352 if (!SWIG_IsOK(res1)) {
17353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17354 }
17355 arg1 = reinterpret_cast< wxFileType * >(argp1);
17356 {
17357 arg2 = wxString_in_helper(obj1);
17358 if (arg2 == NULL) SWIG_fail;
17359 temp2 = true;
17360 }
17361 {
17362 arg3 = wxString_in_helper(obj2);
17363 if (arg3 == NULL) SWIG_fail;
17364 temp3 = true;
17365 }
17366 if (obj3) {
17367 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17368 if (!SWIG_IsOK(ecode4)) {
17369 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17370 }
17371 arg4 = static_cast< bool >(val4);
17372 }
17373 {
17374 PyThreadState* __tstate = wxPyBeginAllowThreads();
17375 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17376 wxPyEndAllowThreads(__tstate);
17377 if (PyErr_Occurred()) SWIG_fail;
17378 }
17379 {
17380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17381 }
17382 {
17383 if (temp2)
17384 delete arg2;
17385 }
17386 {
17387 if (temp3)
17388 delete arg3;
17389 }
17390 return resultobj;
17391 fail:
17392 {
17393 if (temp2)
17394 delete arg2;
17395 }
17396 {
17397 if (temp3)
17398 delete arg3;
17399 }
17400 return NULL;
17401 }
17402
17403
17404 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17405 PyObject *resultobj = 0;
17406 wxFileType *arg1 = (wxFileType *) 0 ;
17407 wxString const &arg2_defvalue = wxPyEmptyString ;
17408 wxString *arg2 = (wxString *) &arg2_defvalue ;
17409 int arg3 = (int) 0 ;
17410 bool result;
17411 void *argp1 = 0 ;
17412 int res1 = 0 ;
17413 bool temp2 = false ;
17414 int val3 ;
17415 int ecode3 = 0 ;
17416 PyObject * obj0 = 0 ;
17417 PyObject * obj1 = 0 ;
17418 PyObject * obj2 = 0 ;
17419 char * kwnames[] = {
17420 (char *) "self",(char *) "cmd",(char *) "index", NULL
17421 };
17422
17423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17425 if (!SWIG_IsOK(res1)) {
17426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17427 }
17428 arg1 = reinterpret_cast< wxFileType * >(argp1);
17429 if (obj1) {
17430 {
17431 arg2 = wxString_in_helper(obj1);
17432 if (arg2 == NULL) SWIG_fail;
17433 temp2 = true;
17434 }
17435 }
17436 if (obj2) {
17437 ecode3 = SWIG_AsVal_int(obj2, &val3);
17438 if (!SWIG_IsOK(ecode3)) {
17439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17440 }
17441 arg3 = static_cast< int >(val3);
17442 }
17443 {
17444 PyThreadState* __tstate = wxPyBeginAllowThreads();
17445 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17446 wxPyEndAllowThreads(__tstate);
17447 if (PyErr_Occurred()) SWIG_fail;
17448 }
17449 {
17450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17451 }
17452 {
17453 if (temp2)
17454 delete arg2;
17455 }
17456 return resultobj;
17457 fail:
17458 {
17459 if (temp2)
17460 delete arg2;
17461 }
17462 return NULL;
17463 }
17464
17465
17466 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 PyObject *resultobj = 0;
17468 wxFileType *arg1 = (wxFileType *) 0 ;
17469 bool result;
17470 void *argp1 = 0 ;
17471 int res1 = 0 ;
17472 PyObject *swig_obj[1] ;
17473
17474 if (!args) SWIG_fail;
17475 swig_obj[0] = args;
17476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17477 if (!SWIG_IsOK(res1)) {
17478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17479 }
17480 arg1 = reinterpret_cast< wxFileType * >(argp1);
17481 {
17482 PyThreadState* __tstate = wxPyBeginAllowThreads();
17483 result = (bool)(arg1)->Unassociate();
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 {
17488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17489 }
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj = 0;
17498 wxString *arg1 = 0 ;
17499 wxString *arg2 = 0 ;
17500 wxString const &arg3_defvalue = wxPyEmptyString ;
17501 wxString *arg3 = (wxString *) &arg3_defvalue ;
17502 wxString result;
17503 bool temp1 = false ;
17504 bool temp2 = false ;
17505 bool temp3 = false ;
17506 PyObject * obj0 = 0 ;
17507 PyObject * obj1 = 0 ;
17508 PyObject * obj2 = 0 ;
17509 char * kwnames[] = {
17510 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17511 };
17512
17513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17514 {
17515 arg1 = wxString_in_helper(obj0);
17516 if (arg1 == NULL) SWIG_fail;
17517 temp1 = true;
17518 }
17519 {
17520 arg2 = wxString_in_helper(obj1);
17521 if (arg2 == NULL) SWIG_fail;
17522 temp2 = true;
17523 }
17524 if (obj2) {
17525 {
17526 arg3 = wxString_in_helper(obj2);
17527 if (arg3 == NULL) SWIG_fail;
17528 temp3 = true;
17529 }
17530 }
17531 {
17532 PyThreadState* __tstate = wxPyBeginAllowThreads();
17533 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17534 wxPyEndAllowThreads(__tstate);
17535 if (PyErr_Occurred()) SWIG_fail;
17536 }
17537 {
17538 #if wxUSE_UNICODE
17539 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17540 #else
17541 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17542 #endif
17543 }
17544 {
17545 if (temp1)
17546 delete arg1;
17547 }
17548 {
17549 if (temp2)
17550 delete arg2;
17551 }
17552 {
17553 if (temp3)
17554 delete arg3;
17555 }
17556 return resultobj;
17557 fail:
17558 {
17559 if (temp1)
17560 delete arg1;
17561 }
17562 {
17563 if (temp2)
17564 delete arg2;
17565 }
17566 {
17567 if (temp3)
17568 delete arg3;
17569 }
17570 return NULL;
17571 }
17572
17573
17574 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17575 PyObject *obj;
17576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17577 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17578 return SWIG_Py_Void();
17579 }
17580
17581 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17582 return SWIG_Python_InitShadowInstance(args);
17583 }
17584
17585 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17586 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17587 return 1;
17588 }
17589
17590
17591 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17592 PyObject *pyobj = 0;
17593
17594 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17595 return pyobj;
17596 }
17597
17598
17599 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj = 0;
17601 wxString *arg1 = 0 ;
17602 wxString *arg2 = 0 ;
17603 bool result;
17604 bool temp1 = false ;
17605 bool temp2 = false ;
17606 PyObject * obj0 = 0 ;
17607 PyObject * obj1 = 0 ;
17608 char * kwnames[] = {
17609 (char *) "mimeType",(char *) "wildcard", NULL
17610 };
17611
17612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17613 {
17614 arg1 = wxString_in_helper(obj0);
17615 if (arg1 == NULL) SWIG_fail;
17616 temp1 = true;
17617 }
17618 {
17619 arg2 = wxString_in_helper(obj1);
17620 if (arg2 == NULL) SWIG_fail;
17621 temp2 = true;
17622 }
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17631 }
17632 {
17633 if (temp1)
17634 delete arg1;
17635 }
17636 {
17637 if (temp2)
17638 delete arg2;
17639 }
17640 return resultobj;
17641 fail:
17642 {
17643 if (temp1)
17644 delete arg1;
17645 }
17646 {
17647 if (temp2)
17648 delete arg2;
17649 }
17650 return NULL;
17651 }
17652
17653
17654 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17655 PyObject *resultobj = 0;
17656 wxMimeTypesManager *result = 0 ;
17657
17658 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17659 {
17660 PyThreadState* __tstate = wxPyBeginAllowThreads();
17661 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17662 wxPyEndAllowThreads(__tstate);
17663 if (PyErr_Occurred()) SWIG_fail;
17664 }
17665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17666 return resultobj;
17667 fail:
17668 return NULL;
17669 }
17670
17671
17672 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17673 PyObject *resultobj = 0;
17674 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17675 int arg2 = (int) wxMAILCAP_ALL ;
17676 wxString const &arg3_defvalue = wxPyEmptyString ;
17677 wxString *arg3 = (wxString *) &arg3_defvalue ;
17678 void *argp1 = 0 ;
17679 int res1 = 0 ;
17680 int val2 ;
17681 int ecode2 = 0 ;
17682 bool temp3 = false ;
17683 PyObject * obj0 = 0 ;
17684 PyObject * obj1 = 0 ;
17685 PyObject * obj2 = 0 ;
17686 char * kwnames[] = {
17687 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17688 };
17689
17690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17692 if (!SWIG_IsOK(res1)) {
17693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17694 }
17695 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17696 if (obj1) {
17697 ecode2 = SWIG_AsVal_int(obj1, &val2);
17698 if (!SWIG_IsOK(ecode2)) {
17699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17700 }
17701 arg2 = static_cast< int >(val2);
17702 }
17703 if (obj2) {
17704 {
17705 arg3 = wxString_in_helper(obj2);
17706 if (arg3 == NULL) SWIG_fail;
17707 temp3 = true;
17708 }
17709 }
17710 {
17711 PyThreadState* __tstate = wxPyBeginAllowThreads();
17712 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_Py_Void();
17717 {
17718 if (temp3)
17719 delete arg3;
17720 }
17721 return resultobj;
17722 fail:
17723 {
17724 if (temp3)
17725 delete arg3;
17726 }
17727 return NULL;
17728 }
17729
17730
17731 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17732 PyObject *resultobj = 0;
17733 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17734 void *argp1 = 0 ;
17735 int res1 = 0 ;
17736 PyObject *swig_obj[1] ;
17737
17738 if (!args) SWIG_fail;
17739 swig_obj[0] = args;
17740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17741 if (!SWIG_IsOK(res1)) {
17742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17743 }
17744 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17745 {
17746 PyThreadState* __tstate = wxPyBeginAllowThreads();
17747 (arg1)->ClearData();
17748 wxPyEndAllowThreads(__tstate);
17749 if (PyErr_Occurred()) SWIG_fail;
17750 }
17751 resultobj = SWIG_Py_Void();
17752 return resultobj;
17753 fail:
17754 return NULL;
17755 }
17756
17757
17758 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17759 PyObject *resultobj = 0;
17760 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17761 wxString *arg2 = 0 ;
17762 wxFileType *result = 0 ;
17763 void *argp1 = 0 ;
17764 int res1 = 0 ;
17765 bool temp2 = false ;
17766 PyObject * obj0 = 0 ;
17767 PyObject * obj1 = 0 ;
17768 char * kwnames[] = {
17769 (char *) "self",(char *) "ext", NULL
17770 };
17771
17772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17774 if (!SWIG_IsOK(res1)) {
17775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17776 }
17777 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17778 {
17779 arg2 = wxString_in_helper(obj1);
17780 if (arg2 == NULL) SWIG_fail;
17781 temp2 = true;
17782 }
17783 {
17784 PyThreadState* __tstate = wxPyBeginAllowThreads();
17785 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17786 wxPyEndAllowThreads(__tstate);
17787 if (PyErr_Occurred()) SWIG_fail;
17788 }
17789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17790 {
17791 if (temp2)
17792 delete arg2;
17793 }
17794 return resultobj;
17795 fail:
17796 {
17797 if (temp2)
17798 delete arg2;
17799 }
17800 return NULL;
17801 }
17802
17803
17804 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj = 0;
17806 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17807 wxString *arg2 = 0 ;
17808 wxFileType *result = 0 ;
17809 void *argp1 = 0 ;
17810 int res1 = 0 ;
17811 bool temp2 = false ;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 char * kwnames[] = {
17815 (char *) "self",(char *) "mimeType", NULL
17816 };
17817
17818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17820 if (!SWIG_IsOK(res1)) {
17821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17822 }
17823 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17824 {
17825 arg2 = wxString_in_helper(obj1);
17826 if (arg2 == NULL) SWIG_fail;
17827 temp2 = true;
17828 }
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17832 wxPyEndAllowThreads(__tstate);
17833 if (PyErr_Occurred()) SWIG_fail;
17834 }
17835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17836 {
17837 if (temp2)
17838 delete arg2;
17839 }
17840 return resultobj;
17841 fail:
17842 {
17843 if (temp2)
17844 delete arg2;
17845 }
17846 return NULL;
17847 }
17848
17849
17850 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17851 PyObject *resultobj = 0;
17852 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17853 wxString *arg2 = 0 ;
17854 bool arg3 = (bool) false ;
17855 bool result;
17856 void *argp1 = 0 ;
17857 int res1 = 0 ;
17858 bool temp2 = false ;
17859 bool val3 ;
17860 int ecode3 = 0 ;
17861 PyObject * obj0 = 0 ;
17862 PyObject * obj1 = 0 ;
17863 PyObject * obj2 = 0 ;
17864 char * kwnames[] = {
17865 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17866 };
17867
17868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17870 if (!SWIG_IsOK(res1)) {
17871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17872 }
17873 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17874 {
17875 arg2 = wxString_in_helper(obj1);
17876 if (arg2 == NULL) SWIG_fail;
17877 temp2 = true;
17878 }
17879 if (obj2) {
17880 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17881 if (!SWIG_IsOK(ecode3)) {
17882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17883 }
17884 arg3 = static_cast< bool >(val3);
17885 }
17886 {
17887 PyThreadState* __tstate = wxPyBeginAllowThreads();
17888 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 {
17893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17894 }
17895 {
17896 if (temp2)
17897 delete arg2;
17898 }
17899 return resultobj;
17900 fail:
17901 {
17902 if (temp2)
17903 delete arg2;
17904 }
17905 return NULL;
17906 }
17907
17908
17909 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj = 0;
17911 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17912 wxString *arg2 = 0 ;
17913 bool result;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 bool temp2 = false ;
17917 PyObject * obj0 = 0 ;
17918 PyObject * obj1 = 0 ;
17919 char * kwnames[] = {
17920 (char *) "self",(char *) "filename", NULL
17921 };
17922
17923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17925 if (!SWIG_IsOK(res1)) {
17926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17927 }
17928 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17929 {
17930 arg2 = wxString_in_helper(obj1);
17931 if (arg2 == NULL) SWIG_fail;
17932 temp2 = true;
17933 }
17934 {
17935 PyThreadState* __tstate = wxPyBeginAllowThreads();
17936 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 {
17941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17942 }
17943 {
17944 if (temp2)
17945 delete arg2;
17946 }
17947 return resultobj;
17948 fail:
17949 {
17950 if (temp2)
17951 delete arg2;
17952 }
17953 return NULL;
17954 }
17955
17956
17957 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17958 PyObject *resultobj = 0;
17959 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17960 PyObject *result = 0 ;
17961 void *argp1 = 0 ;
17962 int res1 = 0 ;
17963 PyObject *swig_obj[1] ;
17964
17965 if (!args) SWIG_fail;
17966 swig_obj[0] = args;
17967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17968 if (!SWIG_IsOK(res1)) {
17969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17970 }
17971 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 resultobj = result;
17979 return resultobj;
17980 fail:
17981 return NULL;
17982 }
17983
17984
17985 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17986 PyObject *resultobj = 0;
17987 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17988 wxFileTypeInfo *arg2 = 0 ;
17989 void *argp1 = 0 ;
17990 int res1 = 0 ;
17991 void *argp2 = 0 ;
17992 int res2 = 0 ;
17993 PyObject * obj0 = 0 ;
17994 PyObject * obj1 = 0 ;
17995 char * kwnames[] = {
17996 (char *) "self",(char *) "ft", NULL
17997 };
17998
17999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18001 if (!SWIG_IsOK(res1)) {
18002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18003 }
18004 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18006 if (!SWIG_IsOK(res2)) {
18007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18008 }
18009 if (!argp2) {
18010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18011 }
18012 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18013 {
18014 PyThreadState* __tstate = wxPyBeginAllowThreads();
18015 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18016 wxPyEndAllowThreads(__tstate);
18017 if (PyErr_Occurred()) SWIG_fail;
18018 }
18019 resultobj = SWIG_Py_Void();
18020 return resultobj;
18021 fail:
18022 return NULL;
18023 }
18024
18025
18026 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18027 PyObject *resultobj = 0;
18028 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18029 wxFileTypeInfo *arg2 = 0 ;
18030 wxFileType *result = 0 ;
18031 void *argp1 = 0 ;
18032 int res1 = 0 ;
18033 void *argp2 = 0 ;
18034 int res2 = 0 ;
18035 PyObject * obj0 = 0 ;
18036 PyObject * obj1 = 0 ;
18037 char * kwnames[] = {
18038 (char *) "self",(char *) "ftInfo", NULL
18039 };
18040
18041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18043 if (!SWIG_IsOK(res1)) {
18044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18045 }
18046 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18048 if (!SWIG_IsOK(res2)) {
18049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18050 }
18051 if (!argp2) {
18052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18053 }
18054 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18055 {
18056 PyThreadState* __tstate = wxPyBeginAllowThreads();
18057 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
18058 wxPyEndAllowThreads(__tstate);
18059 if (PyErr_Occurred()) SWIG_fail;
18060 }
18061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18062 return resultobj;
18063 fail:
18064 return NULL;
18065 }
18066
18067
18068 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18069 PyObject *resultobj = 0;
18070 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18071 wxFileType *arg2 = (wxFileType *) 0 ;
18072 bool result;
18073 void *argp1 = 0 ;
18074 int res1 = 0 ;
18075 void *argp2 = 0 ;
18076 int res2 = 0 ;
18077 PyObject * obj0 = 0 ;
18078 PyObject * obj1 = 0 ;
18079 char * kwnames[] = {
18080 (char *) "self",(char *) "ft", NULL
18081 };
18082
18083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
18084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18085 if (!SWIG_IsOK(res1)) {
18086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18087 }
18088 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
18090 if (!SWIG_IsOK(res2)) {
18091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
18092 }
18093 arg2 = reinterpret_cast< wxFileType * >(argp2);
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 result = (bool)(arg1)->Unassociate(arg2);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 {
18101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18102 }
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18110 PyObject *resultobj = 0;
18111 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18112 void *argp1 = 0 ;
18113 int res1 = 0 ;
18114 PyObject *swig_obj[1] ;
18115
18116 if (!args) SWIG_fail;
18117 swig_obj[0] = args;
18118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18119 if (!SWIG_IsOK(res1)) {
18120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18121 }
18122 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18123 {
18124 PyThreadState* __tstate = wxPyBeginAllowThreads();
18125 delete arg1;
18126
18127 wxPyEndAllowThreads(__tstate);
18128 if (PyErr_Occurred()) SWIG_fail;
18129 }
18130 resultobj = SWIG_Py_Void();
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18138 PyObject *obj;
18139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18140 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18141 return SWIG_Py_Void();
18142 }
18143
18144 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18145 return SWIG_Python_InitShadowInstance(args);
18146 }
18147
18148 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18149 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18150 return 1;
18151 }
18152
18153
18154 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18155 PyObject *pyobj = 0;
18156
18157 {
18158 #if wxUSE_UNICODE
18159 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18160 #else
18161 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18162 #endif
18163 }
18164 return pyobj;
18165 }
18166
18167
18168 SWIGINTERN int ART_MENU_set(PyObject *) {
18169 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18170 return 1;
18171 }
18172
18173
18174 SWIGINTERN PyObject *ART_MENU_get(void) {
18175 PyObject *pyobj = 0;
18176
18177 {
18178 #if wxUSE_UNICODE
18179 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18180 #else
18181 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18182 #endif
18183 }
18184 return pyobj;
18185 }
18186
18187
18188 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18189 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18190 return 1;
18191 }
18192
18193
18194 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18195 PyObject *pyobj = 0;
18196
18197 {
18198 #if wxUSE_UNICODE
18199 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18200 #else
18201 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18202 #endif
18203 }
18204 return pyobj;
18205 }
18206
18207
18208 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18209 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18210 return 1;
18211 }
18212
18213
18214 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18215 PyObject *pyobj = 0;
18216
18217 {
18218 #if wxUSE_UNICODE
18219 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18220 #else
18221 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18222 #endif
18223 }
18224 return pyobj;
18225 }
18226
18227
18228 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18229 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18230 return 1;
18231 }
18232
18233
18234 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18235 PyObject *pyobj = 0;
18236
18237 {
18238 #if wxUSE_UNICODE
18239 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18240 #else
18241 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18242 #endif
18243 }
18244 return pyobj;
18245 }
18246
18247
18248 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18249 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18250 return 1;
18251 }
18252
18253
18254 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18255 PyObject *pyobj = 0;
18256
18257 {
18258 #if wxUSE_UNICODE
18259 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18260 #else
18261 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18262 #endif
18263 }
18264 return pyobj;
18265 }
18266
18267
18268 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18269 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18270 return 1;
18271 }
18272
18273
18274 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18275 PyObject *pyobj = 0;
18276
18277 {
18278 #if wxUSE_UNICODE
18279 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18280 #else
18281 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18282 #endif
18283 }
18284 return pyobj;
18285 }
18286
18287
18288 SWIGINTERN int ART_OTHER_set(PyObject *) {
18289 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18290 return 1;
18291 }
18292
18293
18294 SWIGINTERN PyObject *ART_OTHER_get(void) {
18295 PyObject *pyobj = 0;
18296
18297 {
18298 #if wxUSE_UNICODE
18299 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18300 #else
18301 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18302 #endif
18303 }
18304 return pyobj;
18305 }
18306
18307
18308 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18309 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18310 return 1;
18311 }
18312
18313
18314 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18315 PyObject *pyobj = 0;
18316
18317 {
18318 #if wxUSE_UNICODE
18319 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18320 #else
18321 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18322 #endif
18323 }
18324 return pyobj;
18325 }
18326
18327
18328 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18329 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18330 return 1;
18331 }
18332
18333
18334 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18335 PyObject *pyobj = 0;
18336
18337 {
18338 #if wxUSE_UNICODE
18339 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18340 #else
18341 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18342 #endif
18343 }
18344 return pyobj;
18345 }
18346
18347
18348 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18349 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18350 return 1;
18351 }
18352
18353
18354 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18355 PyObject *pyobj = 0;
18356
18357 {
18358 #if wxUSE_UNICODE
18359 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18360 #else
18361 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18362 #endif
18363 }
18364 return pyobj;
18365 }
18366
18367
18368 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18369 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18370 return 1;
18371 }
18372
18373
18374 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18375 PyObject *pyobj = 0;
18376
18377 {
18378 #if wxUSE_UNICODE
18379 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18380 #else
18381 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18382 #endif
18383 }
18384 return pyobj;
18385 }
18386
18387
18388 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18389 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18390 return 1;
18391 }
18392
18393
18394 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18395 PyObject *pyobj = 0;
18396
18397 {
18398 #if wxUSE_UNICODE
18399 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18400 #else
18401 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18402 #endif
18403 }
18404 return pyobj;
18405 }
18406
18407
18408 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18409 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18410 return 1;
18411 }
18412
18413
18414 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18415 PyObject *pyobj = 0;
18416
18417 {
18418 #if wxUSE_UNICODE
18419 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18420 #else
18421 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18422 #endif
18423 }
18424 return pyobj;
18425 }
18426
18427
18428 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18429 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18430 return 1;
18431 }
18432
18433
18434 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18435 PyObject *pyobj = 0;
18436
18437 {
18438 #if wxUSE_UNICODE
18439 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18440 #else
18441 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18442 #endif
18443 }
18444 return pyobj;
18445 }
18446
18447
18448 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18449 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18450 return 1;
18451 }
18452
18453
18454 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18455 PyObject *pyobj = 0;
18456
18457 {
18458 #if wxUSE_UNICODE
18459 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18460 #else
18461 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18462 #endif
18463 }
18464 return pyobj;
18465 }
18466
18467
18468 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18469 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18470 return 1;
18471 }
18472
18473
18474 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18475 PyObject *pyobj = 0;
18476
18477 {
18478 #if wxUSE_UNICODE
18479 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18480 #else
18481 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18482 #endif
18483 }
18484 return pyobj;
18485 }
18486
18487
18488 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18489 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18490 return 1;
18491 }
18492
18493
18494 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18495 PyObject *pyobj = 0;
18496
18497 {
18498 #if wxUSE_UNICODE
18499 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18500 #else
18501 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18502 #endif
18503 }
18504 return pyobj;
18505 }
18506
18507
18508 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18509 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18510 return 1;
18511 }
18512
18513
18514 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18515 PyObject *pyobj = 0;
18516
18517 {
18518 #if wxUSE_UNICODE
18519 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18520 #else
18521 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18522 #endif
18523 }
18524 return pyobj;
18525 }
18526
18527
18528 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18529 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18530 return 1;
18531 }
18532
18533
18534 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18535 PyObject *pyobj = 0;
18536
18537 {
18538 #if wxUSE_UNICODE
18539 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18540 #else
18541 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18542 #endif
18543 }
18544 return pyobj;
18545 }
18546
18547
18548 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18549 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18550 return 1;
18551 }
18552
18553
18554 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18555 PyObject *pyobj = 0;
18556
18557 {
18558 #if wxUSE_UNICODE
18559 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18560 #else
18561 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18562 #endif
18563 }
18564 return pyobj;
18565 }
18566
18567
18568 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18569 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18570 return 1;
18571 }
18572
18573
18574 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18575 PyObject *pyobj = 0;
18576
18577 {
18578 #if wxUSE_UNICODE
18579 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18580 #else
18581 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18582 #endif
18583 }
18584 return pyobj;
18585 }
18586
18587
18588 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18589 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18590 return 1;
18591 }
18592
18593
18594 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18595 PyObject *pyobj = 0;
18596
18597 {
18598 #if wxUSE_UNICODE
18599 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18600 #else
18601 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18602 #endif
18603 }
18604 return pyobj;
18605 }
18606
18607
18608 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18609 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18610 return 1;
18611 }
18612
18613
18614 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18615 PyObject *pyobj = 0;
18616
18617 {
18618 #if wxUSE_UNICODE
18619 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18620 #else
18621 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18622 #endif
18623 }
18624 return pyobj;
18625 }
18626
18627
18628 SWIGINTERN int ART_PRINT_set(PyObject *) {
18629 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18630 return 1;
18631 }
18632
18633
18634 SWIGINTERN PyObject *ART_PRINT_get(void) {
18635 PyObject *pyobj = 0;
18636
18637 {
18638 #if wxUSE_UNICODE
18639 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18640 #else
18641 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18642 #endif
18643 }
18644 return pyobj;
18645 }
18646
18647
18648 SWIGINTERN int ART_HELP_set(PyObject *) {
18649 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18650 return 1;
18651 }
18652
18653
18654 SWIGINTERN PyObject *ART_HELP_get(void) {
18655 PyObject *pyobj = 0;
18656
18657 {
18658 #if wxUSE_UNICODE
18659 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18660 #else
18661 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18662 #endif
18663 }
18664 return pyobj;
18665 }
18666
18667
18668 SWIGINTERN int ART_TIP_set(PyObject *) {
18669 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18670 return 1;
18671 }
18672
18673
18674 SWIGINTERN PyObject *ART_TIP_get(void) {
18675 PyObject *pyobj = 0;
18676
18677 {
18678 #if wxUSE_UNICODE
18679 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18680 #else
18681 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18682 #endif
18683 }
18684 return pyobj;
18685 }
18686
18687
18688 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18689 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18690 return 1;
18691 }
18692
18693
18694 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18695 PyObject *pyobj = 0;
18696
18697 {
18698 #if wxUSE_UNICODE
18699 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18700 #else
18701 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18702 #endif
18703 }
18704 return pyobj;
18705 }
18706
18707
18708 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18709 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18710 return 1;
18711 }
18712
18713
18714 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18715 PyObject *pyobj = 0;
18716
18717 {
18718 #if wxUSE_UNICODE
18719 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18720 #else
18721 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18722 #endif
18723 }
18724 return pyobj;
18725 }
18726
18727
18728 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18729 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18730 return 1;
18731 }
18732
18733
18734 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18735 PyObject *pyobj = 0;
18736
18737 {
18738 #if wxUSE_UNICODE
18739 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18740 #else
18741 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18742 #endif
18743 }
18744 return pyobj;
18745 }
18746
18747
18748 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18749 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18750 return 1;
18751 }
18752
18753
18754 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18755 PyObject *pyobj = 0;
18756
18757 {
18758 #if wxUSE_UNICODE
18759 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18760 #else
18761 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18762 #endif
18763 }
18764 return pyobj;
18765 }
18766
18767
18768 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18769 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18770 return 1;
18771 }
18772
18773
18774 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18775 PyObject *pyobj = 0;
18776
18777 {
18778 #if wxUSE_UNICODE
18779 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18780 #else
18781 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18782 #endif
18783 }
18784 return pyobj;
18785 }
18786
18787
18788 SWIGINTERN int ART_CDROM_set(PyObject *) {
18789 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18790 return 1;
18791 }
18792
18793
18794 SWIGINTERN PyObject *ART_CDROM_get(void) {
18795 PyObject *pyobj = 0;
18796
18797 {
18798 #if wxUSE_UNICODE
18799 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18800 #else
18801 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18802 #endif
18803 }
18804 return pyobj;
18805 }
18806
18807
18808 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18809 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18810 return 1;
18811 }
18812
18813
18814 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18815 PyObject *pyobj = 0;
18816
18817 {
18818 #if wxUSE_UNICODE
18819 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18820 #else
18821 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18822 #endif
18823 }
18824 return pyobj;
18825 }
18826
18827
18828 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18829 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18830 return 1;
18831 }
18832
18833
18834 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18835 PyObject *pyobj = 0;
18836
18837 {
18838 #if wxUSE_UNICODE
18839 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18840 #else
18841 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18842 #endif
18843 }
18844 return pyobj;
18845 }
18846
18847
18848 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18849 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18850 return 1;
18851 }
18852
18853
18854 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18855 PyObject *pyobj = 0;
18856
18857 {
18858 #if wxUSE_UNICODE
18859 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18860 #else
18861 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18862 #endif
18863 }
18864 return pyobj;
18865 }
18866
18867
18868 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18869 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18870 return 1;
18871 }
18872
18873
18874 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18875 PyObject *pyobj = 0;
18876
18877 {
18878 #if wxUSE_UNICODE
18879 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18880 #else
18881 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18882 #endif
18883 }
18884 return pyobj;
18885 }
18886
18887
18888 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18889 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18890 return 1;
18891 }
18892
18893
18894 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18895 PyObject *pyobj = 0;
18896
18897 {
18898 #if wxUSE_UNICODE
18899 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18900 #else
18901 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18902 #endif
18903 }
18904 return pyobj;
18905 }
18906
18907
18908 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18909 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18910 return 1;
18911 }
18912
18913
18914 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18915 PyObject *pyobj = 0;
18916
18917 {
18918 #if wxUSE_UNICODE
18919 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18920 #else
18921 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18922 #endif
18923 }
18924 return pyobj;
18925 }
18926
18927
18928 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18929 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18930 return 1;
18931 }
18932
18933
18934 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18935 PyObject *pyobj = 0;
18936
18937 {
18938 #if wxUSE_UNICODE
18939 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18940 #else
18941 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18942 #endif
18943 }
18944 return pyobj;
18945 }
18946
18947
18948 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18949 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18950 return 1;
18951 }
18952
18953
18954 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18955 PyObject *pyobj = 0;
18956
18957 {
18958 #if wxUSE_UNICODE
18959 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18960 #else
18961 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18962 #endif
18963 }
18964 return pyobj;
18965 }
18966
18967
18968 SWIGINTERN int ART_ERROR_set(PyObject *) {
18969 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18970 return 1;
18971 }
18972
18973
18974 SWIGINTERN PyObject *ART_ERROR_get(void) {
18975 PyObject *pyobj = 0;
18976
18977 {
18978 #if wxUSE_UNICODE
18979 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18980 #else
18981 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18982 #endif
18983 }
18984 return pyobj;
18985 }
18986
18987
18988 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18989 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18990 return 1;
18991 }
18992
18993
18994 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18995 PyObject *pyobj = 0;
18996
18997 {
18998 #if wxUSE_UNICODE
18999 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19000 #else
19001 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19002 #endif
19003 }
19004 return pyobj;
19005 }
19006
19007
19008 SWIGINTERN int ART_WARNING_set(PyObject *) {
19009 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19010 return 1;
19011 }
19012
19013
19014 SWIGINTERN PyObject *ART_WARNING_get(void) {
19015 PyObject *pyobj = 0;
19016
19017 {
19018 #if wxUSE_UNICODE
19019 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19020 #else
19021 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19022 #endif
19023 }
19024 return pyobj;
19025 }
19026
19027
19028 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19029 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19030 return 1;
19031 }
19032
19033
19034 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19035 PyObject *pyobj = 0;
19036
19037 {
19038 #if wxUSE_UNICODE
19039 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19040 #else
19041 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19042 #endif
19043 }
19044 return pyobj;
19045 }
19046
19047
19048 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19049 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19050 return 1;
19051 }
19052
19053
19054 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19055 PyObject *pyobj = 0;
19056
19057 {
19058 #if wxUSE_UNICODE
19059 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19060 #else
19061 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19062 #endif
19063 }
19064 return pyobj;
19065 }
19066
19067
19068 SWIGINTERN int ART_COPY_set(PyObject *) {
19069 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
19070 return 1;
19071 }
19072
19073
19074 SWIGINTERN PyObject *ART_COPY_get(void) {
19075 PyObject *pyobj = 0;
19076
19077 {
19078 #if wxUSE_UNICODE
19079 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19080 #else
19081 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19082 #endif
19083 }
19084 return pyobj;
19085 }
19086
19087
19088 SWIGINTERN int ART_CUT_set(PyObject *) {
19089 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
19090 return 1;
19091 }
19092
19093
19094 SWIGINTERN PyObject *ART_CUT_get(void) {
19095 PyObject *pyobj = 0;
19096
19097 {
19098 #if wxUSE_UNICODE
19099 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19100 #else
19101 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19102 #endif
19103 }
19104 return pyobj;
19105 }
19106
19107
19108 SWIGINTERN int ART_PASTE_set(PyObject *) {
19109 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
19110 return 1;
19111 }
19112
19113
19114 SWIGINTERN PyObject *ART_PASTE_get(void) {
19115 PyObject *pyobj = 0;
19116
19117 {
19118 #if wxUSE_UNICODE
19119 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19120 #else
19121 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19122 #endif
19123 }
19124 return pyobj;
19125 }
19126
19127
19128 SWIGINTERN int ART_DELETE_set(PyObject *) {
19129 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19130 return 1;
19131 }
19132
19133
19134 SWIGINTERN PyObject *ART_DELETE_get(void) {
19135 PyObject *pyobj = 0;
19136
19137 {
19138 #if wxUSE_UNICODE
19139 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19140 #else
19141 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19142 #endif
19143 }
19144 return pyobj;
19145 }
19146
19147
19148 SWIGINTERN int ART_NEW_set(PyObject *) {
19149 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19150 return 1;
19151 }
19152
19153
19154 SWIGINTERN PyObject *ART_NEW_get(void) {
19155 PyObject *pyobj = 0;
19156
19157 {
19158 #if wxUSE_UNICODE
19159 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19160 #else
19161 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19162 #endif
19163 }
19164 return pyobj;
19165 }
19166
19167
19168 SWIGINTERN int ART_UNDO_set(PyObject *) {
19169 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19170 return 1;
19171 }
19172
19173
19174 SWIGINTERN PyObject *ART_UNDO_get(void) {
19175 PyObject *pyobj = 0;
19176
19177 {
19178 #if wxUSE_UNICODE
19179 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19180 #else
19181 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19182 #endif
19183 }
19184 return pyobj;
19185 }
19186
19187
19188 SWIGINTERN int ART_REDO_set(PyObject *) {
19189 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19190 return 1;
19191 }
19192
19193
19194 SWIGINTERN PyObject *ART_REDO_get(void) {
19195 PyObject *pyobj = 0;
19196
19197 {
19198 #if wxUSE_UNICODE
19199 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19200 #else
19201 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19202 #endif
19203 }
19204 return pyobj;
19205 }
19206
19207
19208 SWIGINTERN int ART_QUIT_set(PyObject *) {
19209 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19210 return 1;
19211 }
19212
19213
19214 SWIGINTERN PyObject *ART_QUIT_get(void) {
19215 PyObject *pyobj = 0;
19216
19217 {
19218 #if wxUSE_UNICODE
19219 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19220 #else
19221 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19222 #endif
19223 }
19224 return pyobj;
19225 }
19226
19227
19228 SWIGINTERN int ART_FIND_set(PyObject *) {
19229 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19230 return 1;
19231 }
19232
19233
19234 SWIGINTERN PyObject *ART_FIND_get(void) {
19235 PyObject *pyobj = 0;
19236
19237 {
19238 #if wxUSE_UNICODE
19239 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19240 #else
19241 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19242 #endif
19243 }
19244 return pyobj;
19245 }
19246
19247
19248 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19249 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19250 return 1;
19251 }
19252
19253
19254 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19255 PyObject *pyobj = 0;
19256
19257 {
19258 #if wxUSE_UNICODE
19259 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19260 #else
19261 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19262 #endif
19263 }
19264 return pyobj;
19265 }
19266
19267
19268 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19269 PyObject *resultobj = 0;
19270 wxPyArtProvider *result = 0 ;
19271
19272 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19273 {
19274 if (!wxPyCheckForApp()) SWIG_fail;
19275 PyThreadState* __tstate = wxPyBeginAllowThreads();
19276 result = (wxPyArtProvider *)new wxPyArtProvider();
19277 wxPyEndAllowThreads(__tstate);
19278 if (PyErr_Occurred()) SWIG_fail;
19279 }
19280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19281 return resultobj;
19282 fail:
19283 return NULL;
19284 }
19285
19286
19287 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19288 PyObject *resultobj = 0;
19289 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19290 void *argp1 = 0 ;
19291 int res1 = 0 ;
19292 PyObject *swig_obj[1] ;
19293
19294 if (!args) SWIG_fail;
19295 swig_obj[0] = args;
19296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19297 if (!SWIG_IsOK(res1)) {
19298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19299 }
19300 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19301 {
19302 PyThreadState* __tstate = wxPyBeginAllowThreads();
19303 delete arg1;
19304
19305 wxPyEndAllowThreads(__tstate);
19306 if (PyErr_Occurred()) SWIG_fail;
19307 }
19308 resultobj = SWIG_Py_Void();
19309 return resultobj;
19310 fail:
19311 return NULL;
19312 }
19313
19314
19315 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19316 PyObject *resultobj = 0;
19317 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19318 PyObject *arg2 = (PyObject *) 0 ;
19319 PyObject *arg3 = (PyObject *) 0 ;
19320 void *argp1 = 0 ;
19321 int res1 = 0 ;
19322 PyObject * obj0 = 0 ;
19323 PyObject * obj1 = 0 ;
19324 PyObject * obj2 = 0 ;
19325 char * kwnames[] = {
19326 (char *) "self",(char *) "self",(char *) "_class", NULL
19327 };
19328
19329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19331 if (!SWIG_IsOK(res1)) {
19332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19333 }
19334 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19335 arg2 = obj1;
19336 arg3 = obj2;
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 (arg1)->_setCallbackInfo(arg2,arg3);
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_Py_Void();
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19351 PyObject *resultobj = 0;
19352 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19353 int res1 = 0 ;
19354 PyObject * obj0 = 0 ;
19355 char * kwnames[] = {
19356 (char *) "provider", NULL
19357 };
19358
19359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19360 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19363 }
19364 {
19365 PyThreadState* __tstate = wxPyBeginAllowThreads();
19366 wxPyArtProvider::PushProvider(arg1);
19367 wxPyEndAllowThreads(__tstate);
19368 if (PyErr_Occurred()) SWIG_fail;
19369 }
19370 resultobj = SWIG_Py_Void();
19371 return resultobj;
19372 fail:
19373 return NULL;
19374 }
19375
19376
19377 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19378 PyObject *resultobj = 0;
19379 bool result;
19380
19381 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19382 {
19383 PyThreadState* __tstate = wxPyBeginAllowThreads();
19384 result = (bool)wxPyArtProvider::PopProvider();
19385 wxPyEndAllowThreads(__tstate);
19386 if (PyErr_Occurred()) SWIG_fail;
19387 }
19388 {
19389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19390 }
19391 return resultobj;
19392 fail:
19393 return NULL;
19394 }
19395
19396
19397 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19398 PyObject *resultobj = 0;
19399 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19400 bool result;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject * obj0 = 0 ;
19404 char * kwnames[] = {
19405 (char *) "provider", NULL
19406 };
19407
19408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19410 if (!SWIG_IsOK(res1)) {
19411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19412 }
19413 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19414 {
19415 PyThreadState* __tstate = wxPyBeginAllowThreads();
19416 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19417 wxPyEndAllowThreads(__tstate);
19418 if (PyErr_Occurred()) SWIG_fail;
19419 }
19420 {
19421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19422 }
19423 return resultobj;
19424 fail:
19425 return NULL;
19426 }
19427
19428
19429 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19430 PyObject *resultobj = 0;
19431 wxString *arg1 = 0 ;
19432 wxString const &arg2_defvalue = wxPyART_OTHER ;
19433 wxString *arg2 = (wxString *) &arg2_defvalue ;
19434 wxSize const &arg3_defvalue = wxDefaultSize ;
19435 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19436 wxBitmap result;
19437 bool temp1 = false ;
19438 bool temp2 = false ;
19439 wxSize temp3 ;
19440 PyObject * obj0 = 0 ;
19441 PyObject * obj1 = 0 ;
19442 PyObject * obj2 = 0 ;
19443 char * kwnames[] = {
19444 (char *) "id",(char *) "client",(char *) "size", NULL
19445 };
19446
19447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19448 {
19449 arg1 = wxString_in_helper(obj0);
19450 if (arg1 == NULL) SWIG_fail;
19451 temp1 = true;
19452 }
19453 if (obj1) {
19454 {
19455 arg2 = wxString_in_helper(obj1);
19456 if (arg2 == NULL) SWIG_fail;
19457 temp2 = true;
19458 }
19459 }
19460 if (obj2) {
19461 {
19462 arg3 = &temp3;
19463 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19464 }
19465 }
19466 {
19467 if (!wxPyCheckForApp()) SWIG_fail;
19468 PyThreadState* __tstate = wxPyBeginAllowThreads();
19469 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19470 wxPyEndAllowThreads(__tstate);
19471 if (PyErr_Occurred()) SWIG_fail;
19472 }
19473 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19474 {
19475 if (temp1)
19476 delete arg1;
19477 }
19478 {
19479 if (temp2)
19480 delete arg2;
19481 }
19482 return resultobj;
19483 fail:
19484 {
19485 if (temp1)
19486 delete arg1;
19487 }
19488 {
19489 if (temp2)
19490 delete arg2;
19491 }
19492 return NULL;
19493 }
19494
19495
19496 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19497 PyObject *resultobj = 0;
19498 wxString *arg1 = 0 ;
19499 wxString const &arg2_defvalue = wxPyART_OTHER ;
19500 wxString *arg2 = (wxString *) &arg2_defvalue ;
19501 wxSize const &arg3_defvalue = wxDefaultSize ;
19502 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19503 wxIcon result;
19504 bool temp1 = false ;
19505 bool temp2 = false ;
19506 wxSize temp3 ;
19507 PyObject * obj0 = 0 ;
19508 PyObject * obj1 = 0 ;
19509 PyObject * obj2 = 0 ;
19510 char * kwnames[] = {
19511 (char *) "id",(char *) "client",(char *) "size", NULL
19512 };
19513
19514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19515 {
19516 arg1 = wxString_in_helper(obj0);
19517 if (arg1 == NULL) SWIG_fail;
19518 temp1 = true;
19519 }
19520 if (obj1) {
19521 {
19522 arg2 = wxString_in_helper(obj1);
19523 if (arg2 == NULL) SWIG_fail;
19524 temp2 = true;
19525 }
19526 }
19527 if (obj2) {
19528 {
19529 arg3 = &temp3;
19530 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19531 }
19532 }
19533 {
19534 if (!wxPyCheckForApp()) SWIG_fail;
19535 PyThreadState* __tstate = wxPyBeginAllowThreads();
19536 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19537 wxPyEndAllowThreads(__tstate);
19538 if (PyErr_Occurred()) SWIG_fail;
19539 }
19540 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19541 {
19542 if (temp1)
19543 delete arg1;
19544 }
19545 {
19546 if (temp2)
19547 delete arg2;
19548 }
19549 return resultobj;
19550 fail:
19551 {
19552 if (temp1)
19553 delete arg1;
19554 }
19555 {
19556 if (temp2)
19557 delete arg2;
19558 }
19559 return NULL;
19560 }
19561
19562
19563 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj = 0;
19565 wxString *arg1 = 0 ;
19566 bool arg2 = (bool) false ;
19567 wxSize result;
19568 bool temp1 = false ;
19569 bool val2 ;
19570 int ecode2 = 0 ;
19571 PyObject * obj0 = 0 ;
19572 PyObject * obj1 = 0 ;
19573 char * kwnames[] = {
19574 (char *) "client",(char *) "platform_dependent", NULL
19575 };
19576
19577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19578 {
19579 arg1 = wxString_in_helper(obj0);
19580 if (arg1 == NULL) SWIG_fail;
19581 temp1 = true;
19582 }
19583 if (obj1) {
19584 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19585 if (!SWIG_IsOK(ecode2)) {
19586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19587 }
19588 arg2 = static_cast< bool >(val2);
19589 }
19590 {
19591 PyThreadState* __tstate = wxPyBeginAllowThreads();
19592 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19593 wxPyEndAllowThreads(__tstate);
19594 if (PyErr_Occurred()) SWIG_fail;
19595 }
19596 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19597 {
19598 if (temp1)
19599 delete arg1;
19600 }
19601 return resultobj;
19602 fail:
19603 {
19604 if (temp1)
19605 delete arg1;
19606 }
19607 return NULL;
19608 }
19609
19610
19611 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19612 PyObject *resultobj = 0;
19613 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19614 void *argp1 = 0 ;
19615 int res1 = 0 ;
19616 PyObject *swig_obj[1] ;
19617
19618 if (!args) SWIG_fail;
19619 swig_obj[0] = args;
19620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19621 if (!SWIG_IsOK(res1)) {
19622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19623 }
19624 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19625 {
19626 PyThreadState* __tstate = wxPyBeginAllowThreads();
19627 wxPyArtProvider_Destroy(arg1);
19628 wxPyEndAllowThreads(__tstate);
19629 if (PyErr_Occurred()) SWIG_fail;
19630 }
19631 resultobj = SWIG_Py_Void();
19632 return resultobj;
19633 fail:
19634 return NULL;
19635 }
19636
19637
19638 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19639 PyObject *obj;
19640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19641 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19642 return SWIG_Py_Void();
19643 }
19644
19645 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19646 return SWIG_Python_InitShadowInstance(args);
19647 }
19648
19649 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19650 PyObject *resultobj = 0;
19651 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19652 void *argp1 = 0 ;
19653 int res1 = 0 ;
19654 PyObject *swig_obj[1] ;
19655
19656 if (!args) SWIG_fail;
19657 swig_obj[0] = args;
19658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19659 if (!SWIG_IsOK(res1)) {
19660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19661 }
19662 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19663 {
19664 PyThreadState* __tstate = wxPyBeginAllowThreads();
19665 delete arg1;
19666
19667 wxPyEndAllowThreads(__tstate);
19668 if (PyErr_Occurred()) SWIG_fail;
19669 }
19670 resultobj = SWIG_Py_Void();
19671 return resultobj;
19672 fail:
19673 return NULL;
19674 }
19675
19676
19677 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19678 PyObject *resultobj = 0;
19679 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19680 wxConfigBase *result = 0 ;
19681 int res1 = 0 ;
19682 PyObject * obj0 = 0 ;
19683 char * kwnames[] = {
19684 (char *) "config", NULL
19685 };
19686
19687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19688 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19689 if (!SWIG_IsOK(res1)) {
19690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19691 }
19692 {
19693 PyThreadState* __tstate = wxPyBeginAllowThreads();
19694 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19706 PyObject *resultobj = 0;
19707 bool arg1 = (bool) true ;
19708 wxConfigBase *result = 0 ;
19709 bool val1 ;
19710 int ecode1 = 0 ;
19711 PyObject * obj0 = 0 ;
19712 char * kwnames[] = {
19713 (char *) "createOnDemand", NULL
19714 };
19715
19716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19717 if (obj0) {
19718 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19719 if (!SWIG_IsOK(ecode1)) {
19720 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19721 }
19722 arg1 = static_cast< bool >(val1);
19723 }
19724 {
19725 PyThreadState* __tstate = wxPyBeginAllowThreads();
19726 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19738 PyObject *resultobj = 0;
19739 wxConfigBase *result = 0 ;
19740
19741 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 result = (wxConfigBase *)wxConfigBase::Create();
19745 wxPyEndAllowThreads(__tstate);
19746 if (PyErr_Occurred()) SWIG_fail;
19747 }
19748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19756 PyObject *resultobj = 0;
19757
19758 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19759 {
19760 PyThreadState* __tstate = wxPyBeginAllowThreads();
19761 wxConfigBase::DontCreateOnDemand();
19762 wxPyEndAllowThreads(__tstate);
19763 if (PyErr_Occurred()) SWIG_fail;
19764 }
19765 resultobj = SWIG_Py_Void();
19766 return resultobj;
19767 fail:
19768 return NULL;
19769 }
19770
19771
19772 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19773 PyObject *resultobj = 0;
19774 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19775 wxString *arg2 = 0 ;
19776 void *argp1 = 0 ;
19777 int res1 = 0 ;
19778 bool temp2 = false ;
19779 PyObject * obj0 = 0 ;
19780 PyObject * obj1 = 0 ;
19781 char * kwnames[] = {
19782 (char *) "self",(char *) "path", NULL
19783 };
19784
19785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19787 if (!SWIG_IsOK(res1)) {
19788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19789 }
19790 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19791 {
19792 arg2 = wxString_in_helper(obj1);
19793 if (arg2 == NULL) SWIG_fail;
19794 temp2 = true;
19795 }
19796 {
19797 PyThreadState* __tstate = wxPyBeginAllowThreads();
19798 (arg1)->SetPath((wxString const &)*arg2);
19799 wxPyEndAllowThreads(__tstate);
19800 if (PyErr_Occurred()) SWIG_fail;
19801 }
19802 resultobj = SWIG_Py_Void();
19803 {
19804 if (temp2)
19805 delete arg2;
19806 }
19807 return resultobj;
19808 fail:
19809 {
19810 if (temp2)
19811 delete arg2;
19812 }
19813 return NULL;
19814 }
19815
19816
19817 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19818 PyObject *resultobj = 0;
19819 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19820 wxString *result = 0 ;
19821 void *argp1 = 0 ;
19822 int res1 = 0 ;
19823 PyObject *swig_obj[1] ;
19824
19825 if (!args) SWIG_fail;
19826 swig_obj[0] = args;
19827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19828 if (!SWIG_IsOK(res1)) {
19829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19830 }
19831 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19832 {
19833 PyThreadState* __tstate = wxPyBeginAllowThreads();
19834 {
19835 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19836 result = (wxString *) &_result_ref;
19837 }
19838 wxPyEndAllowThreads(__tstate);
19839 if (PyErr_Occurred()) SWIG_fail;
19840 }
19841 {
19842 #if wxUSE_UNICODE
19843 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19844 #else
19845 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19846 #endif
19847 }
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19855 PyObject *resultobj = 0;
19856 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19857 PyObject *result = 0 ;
19858 void *argp1 = 0 ;
19859 int res1 = 0 ;
19860 PyObject *swig_obj[1] ;
19861
19862 if (!args) SWIG_fail;
19863 swig_obj[0] = args;
19864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19865 if (!SWIG_IsOK(res1)) {
19866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19867 }
19868 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19872 wxPyEndAllowThreads(__tstate);
19873 if (PyErr_Occurred()) SWIG_fail;
19874 }
19875 resultobj = result;
19876 return resultobj;
19877 fail:
19878 return NULL;
19879 }
19880
19881
19882 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19883 PyObject *resultobj = 0;
19884 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19885 long arg2 ;
19886 PyObject *result = 0 ;
19887 void *argp1 = 0 ;
19888 int res1 = 0 ;
19889 long val2 ;
19890 int ecode2 = 0 ;
19891 PyObject * obj0 = 0 ;
19892 PyObject * obj1 = 0 ;
19893 char * kwnames[] = {
19894 (char *) "self",(char *) "index", NULL
19895 };
19896
19897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19899 if (!SWIG_IsOK(res1)) {
19900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19901 }
19902 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19903 ecode2 = SWIG_AsVal_long(obj1, &val2);
19904 if (!SWIG_IsOK(ecode2)) {
19905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19906 }
19907 arg2 = static_cast< long >(val2);
19908 {
19909 PyThreadState* __tstate = wxPyBeginAllowThreads();
19910 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19911 wxPyEndAllowThreads(__tstate);
19912 if (PyErr_Occurred()) SWIG_fail;
19913 }
19914 resultobj = result;
19915 return resultobj;
19916 fail:
19917 return NULL;
19918 }
19919
19920
19921 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19922 PyObject *resultobj = 0;
19923 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19924 PyObject *result = 0 ;
19925 void *argp1 = 0 ;
19926 int res1 = 0 ;
19927 PyObject *swig_obj[1] ;
19928
19929 if (!args) SWIG_fail;
19930 swig_obj[0] = args;
19931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19932 if (!SWIG_IsOK(res1)) {
19933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19934 }
19935 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19939 wxPyEndAllowThreads(__tstate);
19940 if (PyErr_Occurred()) SWIG_fail;
19941 }
19942 resultobj = result;
19943 return resultobj;
19944 fail:
19945 return NULL;
19946 }
19947
19948
19949 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19950 PyObject *resultobj = 0;
19951 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19952 long arg2 ;
19953 PyObject *result = 0 ;
19954 void *argp1 = 0 ;
19955 int res1 = 0 ;
19956 long val2 ;
19957 int ecode2 = 0 ;
19958 PyObject * obj0 = 0 ;
19959 PyObject * obj1 = 0 ;
19960 char * kwnames[] = {
19961 (char *) "self",(char *) "index", NULL
19962 };
19963
19964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19966 if (!SWIG_IsOK(res1)) {
19967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19968 }
19969 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19970 ecode2 = SWIG_AsVal_long(obj1, &val2);
19971 if (!SWIG_IsOK(ecode2)) {
19972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19973 }
19974 arg2 = static_cast< long >(val2);
19975 {
19976 PyThreadState* __tstate = wxPyBeginAllowThreads();
19977 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 resultobj = result;
19982 return resultobj;
19983 fail:
19984 return NULL;
19985 }
19986
19987
19988 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19989 PyObject *resultobj = 0;
19990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19991 bool arg2 = (bool) false ;
19992 size_t result;
19993 void *argp1 = 0 ;
19994 int res1 = 0 ;
19995 bool val2 ;
19996 int ecode2 = 0 ;
19997 PyObject * obj0 = 0 ;
19998 PyObject * obj1 = 0 ;
19999 char * kwnames[] = {
20000 (char *) "self",(char *) "recursive", NULL
20001 };
20002
20003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20005 if (!SWIG_IsOK(res1)) {
20006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20007 }
20008 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20009 if (obj1) {
20010 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20011 if (!SWIG_IsOK(ecode2)) {
20012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20013 }
20014 arg2 = static_cast< bool >(val2);
20015 }
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20019 wxPyEndAllowThreads(__tstate);
20020 if (PyErr_Occurred()) SWIG_fail;
20021 }
20022 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20023 return resultobj;
20024 fail:
20025 return NULL;
20026 }
20027
20028
20029 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20030 PyObject *resultobj = 0;
20031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20032 bool arg2 = (bool) false ;
20033 size_t result;
20034 void *argp1 = 0 ;
20035 int res1 = 0 ;
20036 bool val2 ;
20037 int ecode2 = 0 ;
20038 PyObject * obj0 = 0 ;
20039 PyObject * obj1 = 0 ;
20040 char * kwnames[] = {
20041 (char *) "self",(char *) "recursive", NULL
20042 };
20043
20044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20046 if (!SWIG_IsOK(res1)) {
20047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20048 }
20049 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20050 if (obj1) {
20051 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20052 if (!SWIG_IsOK(ecode2)) {
20053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
20054 }
20055 arg2 = static_cast< bool >(val2);
20056 }
20057 {
20058 PyThreadState* __tstate = wxPyBeginAllowThreads();
20059 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
20060 wxPyEndAllowThreads(__tstate);
20061 if (PyErr_Occurred()) SWIG_fail;
20062 }
20063 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20064 return resultobj;
20065 fail:
20066 return NULL;
20067 }
20068
20069
20070 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20071 PyObject *resultobj = 0;
20072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20073 wxString *arg2 = 0 ;
20074 bool result;
20075 void *argp1 = 0 ;
20076 int res1 = 0 ;
20077 bool temp2 = false ;
20078 PyObject * obj0 = 0 ;
20079 PyObject * obj1 = 0 ;
20080 char * kwnames[] = {
20081 (char *) "self",(char *) "name", NULL
20082 };
20083
20084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20086 if (!SWIG_IsOK(res1)) {
20087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20088 }
20089 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20090 {
20091 arg2 = wxString_in_helper(obj1);
20092 if (arg2 == NULL) SWIG_fail;
20093 temp2 = true;
20094 }
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
20098 wxPyEndAllowThreads(__tstate);
20099 if (PyErr_Occurred()) SWIG_fail;
20100 }
20101 {
20102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20103 }
20104 {
20105 if (temp2)
20106 delete arg2;
20107 }
20108 return resultobj;
20109 fail:
20110 {
20111 if (temp2)
20112 delete arg2;
20113 }
20114 return NULL;
20115 }
20116
20117
20118 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20119 PyObject *resultobj = 0;
20120 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20121 wxString *arg2 = 0 ;
20122 bool result;
20123 void *argp1 = 0 ;
20124 int res1 = 0 ;
20125 bool temp2 = false ;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 char * kwnames[] = {
20129 (char *) "self",(char *) "name", NULL
20130 };
20131
20132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20134 if (!SWIG_IsOK(res1)) {
20135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20136 }
20137 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20138 {
20139 arg2 = wxString_in_helper(obj1);
20140 if (arg2 == NULL) SWIG_fail;
20141 temp2 = true;
20142 }
20143 {
20144 PyThreadState* __tstate = wxPyBeginAllowThreads();
20145 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 {
20150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20151 }
20152 {
20153 if (temp2)
20154 delete arg2;
20155 }
20156 return resultobj;
20157 fail:
20158 {
20159 if (temp2)
20160 delete arg2;
20161 }
20162 return NULL;
20163 }
20164
20165
20166 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20167 PyObject *resultobj = 0;
20168 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20169 wxString *arg2 = 0 ;
20170 bool result;
20171 void *argp1 = 0 ;
20172 int res1 = 0 ;
20173 bool temp2 = false ;
20174 PyObject * obj0 = 0 ;
20175 PyObject * obj1 = 0 ;
20176 char * kwnames[] = {
20177 (char *) "self",(char *) "name", NULL
20178 };
20179
20180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20182 if (!SWIG_IsOK(res1)) {
20183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20184 }
20185 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20186 {
20187 arg2 = wxString_in_helper(obj1);
20188 if (arg2 == NULL) SWIG_fail;
20189 temp2 = true;
20190 }
20191 {
20192 PyThreadState* __tstate = wxPyBeginAllowThreads();
20193 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20194 wxPyEndAllowThreads(__tstate);
20195 if (PyErr_Occurred()) SWIG_fail;
20196 }
20197 {
20198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20199 }
20200 {
20201 if (temp2)
20202 delete arg2;
20203 }
20204 return resultobj;
20205 fail:
20206 {
20207 if (temp2)
20208 delete arg2;
20209 }
20210 return NULL;
20211 }
20212
20213
20214 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20215 PyObject *resultobj = 0;
20216 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20217 wxString *arg2 = 0 ;
20218 wxConfigBase::EntryType result;
20219 void *argp1 = 0 ;
20220 int res1 = 0 ;
20221 bool temp2 = false ;
20222 PyObject * obj0 = 0 ;
20223 PyObject * obj1 = 0 ;
20224 char * kwnames[] = {
20225 (char *) "self",(char *) "name", NULL
20226 };
20227
20228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20230 if (!SWIG_IsOK(res1)) {
20231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20232 }
20233 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20234 {
20235 arg2 = wxString_in_helper(obj1);
20236 if (arg2 == NULL) SWIG_fail;
20237 temp2 = true;
20238 }
20239 {
20240 PyThreadState* __tstate = wxPyBeginAllowThreads();
20241 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20242 wxPyEndAllowThreads(__tstate);
20243 if (PyErr_Occurred()) SWIG_fail;
20244 }
20245 resultobj = SWIG_From_int(static_cast< int >(result));
20246 {
20247 if (temp2)
20248 delete arg2;
20249 }
20250 return resultobj;
20251 fail:
20252 {
20253 if (temp2)
20254 delete arg2;
20255 }
20256 return NULL;
20257 }
20258
20259
20260 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20261 PyObject *resultobj = 0;
20262 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20263 wxString *arg2 = 0 ;
20264 wxString const &arg3_defvalue = wxPyEmptyString ;
20265 wxString *arg3 = (wxString *) &arg3_defvalue ;
20266 wxString result;
20267 void *argp1 = 0 ;
20268 int res1 = 0 ;
20269 bool temp2 = false ;
20270 bool temp3 = false ;
20271 PyObject * obj0 = 0 ;
20272 PyObject * obj1 = 0 ;
20273 PyObject * obj2 = 0 ;
20274 char * kwnames[] = {
20275 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20276 };
20277
20278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20280 if (!SWIG_IsOK(res1)) {
20281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20282 }
20283 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20284 {
20285 arg2 = wxString_in_helper(obj1);
20286 if (arg2 == NULL) SWIG_fail;
20287 temp2 = true;
20288 }
20289 if (obj2) {
20290 {
20291 arg3 = wxString_in_helper(obj2);
20292 if (arg3 == NULL) SWIG_fail;
20293 temp3 = true;
20294 }
20295 }
20296 {
20297 PyThreadState* __tstate = wxPyBeginAllowThreads();
20298 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20299 wxPyEndAllowThreads(__tstate);
20300 if (PyErr_Occurred()) SWIG_fail;
20301 }
20302 {
20303 #if wxUSE_UNICODE
20304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20305 #else
20306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20307 #endif
20308 }
20309 {
20310 if (temp2)
20311 delete arg2;
20312 }
20313 {
20314 if (temp3)
20315 delete arg3;
20316 }
20317 return resultobj;
20318 fail:
20319 {
20320 if (temp2)
20321 delete arg2;
20322 }
20323 {
20324 if (temp3)
20325 delete arg3;
20326 }
20327 return NULL;
20328 }
20329
20330
20331 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20332 PyObject *resultobj = 0;
20333 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20334 wxString *arg2 = 0 ;
20335 long arg3 = (long) 0 ;
20336 long result;
20337 void *argp1 = 0 ;
20338 int res1 = 0 ;
20339 bool temp2 = false ;
20340 long val3 ;
20341 int ecode3 = 0 ;
20342 PyObject * obj0 = 0 ;
20343 PyObject * obj1 = 0 ;
20344 PyObject * obj2 = 0 ;
20345 char * kwnames[] = {
20346 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20347 };
20348
20349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20351 if (!SWIG_IsOK(res1)) {
20352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20353 }
20354 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20355 {
20356 arg2 = wxString_in_helper(obj1);
20357 if (arg2 == NULL) SWIG_fail;
20358 temp2 = true;
20359 }
20360 if (obj2) {
20361 ecode3 = SWIG_AsVal_long(obj2, &val3);
20362 if (!SWIG_IsOK(ecode3)) {
20363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20364 }
20365 arg3 = static_cast< long >(val3);
20366 }
20367 {
20368 PyThreadState* __tstate = wxPyBeginAllowThreads();
20369 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20370 wxPyEndAllowThreads(__tstate);
20371 if (PyErr_Occurred()) SWIG_fail;
20372 }
20373 resultobj = SWIG_From_long(static_cast< long >(result));
20374 {
20375 if (temp2)
20376 delete arg2;
20377 }
20378 return resultobj;
20379 fail:
20380 {
20381 if (temp2)
20382 delete arg2;
20383 }
20384 return NULL;
20385 }
20386
20387
20388 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20389 PyObject *resultobj = 0;
20390 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20391 wxString *arg2 = 0 ;
20392 double arg3 = (double) 0.0 ;
20393 double result;
20394 void *argp1 = 0 ;
20395 int res1 = 0 ;
20396 bool temp2 = false ;
20397 double val3 ;
20398 int ecode3 = 0 ;
20399 PyObject * obj0 = 0 ;
20400 PyObject * obj1 = 0 ;
20401 PyObject * obj2 = 0 ;
20402 char * kwnames[] = {
20403 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20404 };
20405
20406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20408 if (!SWIG_IsOK(res1)) {
20409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20410 }
20411 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20412 {
20413 arg2 = wxString_in_helper(obj1);
20414 if (arg2 == NULL) SWIG_fail;
20415 temp2 = true;
20416 }
20417 if (obj2) {
20418 ecode3 = SWIG_AsVal_double(obj2, &val3);
20419 if (!SWIG_IsOK(ecode3)) {
20420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20421 }
20422 arg3 = static_cast< double >(val3);
20423 }
20424 {
20425 PyThreadState* __tstate = wxPyBeginAllowThreads();
20426 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20427 wxPyEndAllowThreads(__tstate);
20428 if (PyErr_Occurred()) SWIG_fail;
20429 }
20430 resultobj = SWIG_From_double(static_cast< double >(result));
20431 {
20432 if (temp2)
20433 delete arg2;
20434 }
20435 return resultobj;
20436 fail:
20437 {
20438 if (temp2)
20439 delete arg2;
20440 }
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20446 PyObject *resultobj = 0;
20447 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20448 wxString *arg2 = 0 ;
20449 bool arg3 = (bool) false ;
20450 bool result;
20451 void *argp1 = 0 ;
20452 int res1 = 0 ;
20453 bool temp2 = false ;
20454 bool val3 ;
20455 int ecode3 = 0 ;
20456 PyObject * obj0 = 0 ;
20457 PyObject * obj1 = 0 ;
20458 PyObject * obj2 = 0 ;
20459 char * kwnames[] = {
20460 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20461 };
20462
20463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20465 if (!SWIG_IsOK(res1)) {
20466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20467 }
20468 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20469 {
20470 arg2 = wxString_in_helper(obj1);
20471 if (arg2 == NULL) SWIG_fail;
20472 temp2 = true;
20473 }
20474 if (obj2) {
20475 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20476 if (!SWIG_IsOK(ecode3)) {
20477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20478 }
20479 arg3 = static_cast< bool >(val3);
20480 }
20481 {
20482 PyThreadState* __tstate = wxPyBeginAllowThreads();
20483 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 {
20488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20489 }
20490 {
20491 if (temp2)
20492 delete arg2;
20493 }
20494 return resultobj;
20495 fail:
20496 {
20497 if (temp2)
20498 delete arg2;
20499 }
20500 return NULL;
20501 }
20502
20503
20504 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20505 PyObject *resultobj = 0;
20506 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20507 wxString *arg2 = 0 ;
20508 wxString *arg3 = 0 ;
20509 bool result;
20510 void *argp1 = 0 ;
20511 int res1 = 0 ;
20512 bool temp2 = false ;
20513 bool temp3 = false ;
20514 PyObject * obj0 = 0 ;
20515 PyObject * obj1 = 0 ;
20516 PyObject * obj2 = 0 ;
20517 char * kwnames[] = {
20518 (char *) "self",(char *) "key",(char *) "value", NULL
20519 };
20520
20521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20523 if (!SWIG_IsOK(res1)) {
20524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20525 }
20526 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20527 {
20528 arg2 = wxString_in_helper(obj1);
20529 if (arg2 == NULL) SWIG_fail;
20530 temp2 = true;
20531 }
20532 {
20533 arg3 = wxString_in_helper(obj2);
20534 if (arg3 == NULL) SWIG_fail;
20535 temp3 = true;
20536 }
20537 {
20538 PyThreadState* __tstate = wxPyBeginAllowThreads();
20539 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 {
20544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20545 }
20546 {
20547 if (temp2)
20548 delete arg2;
20549 }
20550 {
20551 if (temp3)
20552 delete arg3;
20553 }
20554 return resultobj;
20555 fail:
20556 {
20557 if (temp2)
20558 delete arg2;
20559 }
20560 {
20561 if (temp3)
20562 delete arg3;
20563 }
20564 return NULL;
20565 }
20566
20567
20568 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20569 PyObject *resultobj = 0;
20570 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20571 wxString *arg2 = 0 ;
20572 long arg3 ;
20573 bool result;
20574 void *argp1 = 0 ;
20575 int res1 = 0 ;
20576 bool temp2 = false ;
20577 long val3 ;
20578 int ecode3 = 0 ;
20579 PyObject * obj0 = 0 ;
20580 PyObject * obj1 = 0 ;
20581 PyObject * obj2 = 0 ;
20582 char * kwnames[] = {
20583 (char *) "self",(char *) "key",(char *) "value", NULL
20584 };
20585
20586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20588 if (!SWIG_IsOK(res1)) {
20589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20590 }
20591 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20592 {
20593 arg2 = wxString_in_helper(obj1);
20594 if (arg2 == NULL) SWIG_fail;
20595 temp2 = true;
20596 }
20597 ecode3 = SWIG_AsVal_long(obj2, &val3);
20598 if (!SWIG_IsOK(ecode3)) {
20599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20600 }
20601 arg3 = static_cast< long >(val3);
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20605 wxPyEndAllowThreads(__tstate);
20606 if (PyErr_Occurred()) SWIG_fail;
20607 }
20608 {
20609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20610 }
20611 {
20612 if (temp2)
20613 delete arg2;
20614 }
20615 return resultobj;
20616 fail:
20617 {
20618 if (temp2)
20619 delete arg2;
20620 }
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20626 PyObject *resultobj = 0;
20627 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20628 wxString *arg2 = 0 ;
20629 double arg3 ;
20630 bool result;
20631 void *argp1 = 0 ;
20632 int res1 = 0 ;
20633 bool temp2 = false ;
20634 double val3 ;
20635 int ecode3 = 0 ;
20636 PyObject * obj0 = 0 ;
20637 PyObject * obj1 = 0 ;
20638 PyObject * obj2 = 0 ;
20639 char * kwnames[] = {
20640 (char *) "self",(char *) "key",(char *) "value", NULL
20641 };
20642
20643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20645 if (!SWIG_IsOK(res1)) {
20646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20647 }
20648 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20649 {
20650 arg2 = wxString_in_helper(obj1);
20651 if (arg2 == NULL) SWIG_fail;
20652 temp2 = true;
20653 }
20654 ecode3 = SWIG_AsVal_double(obj2, &val3);
20655 if (!SWIG_IsOK(ecode3)) {
20656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20657 }
20658 arg3 = static_cast< double >(val3);
20659 {
20660 PyThreadState* __tstate = wxPyBeginAllowThreads();
20661 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20662 wxPyEndAllowThreads(__tstate);
20663 if (PyErr_Occurred()) SWIG_fail;
20664 }
20665 {
20666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20667 }
20668 {
20669 if (temp2)
20670 delete arg2;
20671 }
20672 return resultobj;
20673 fail:
20674 {
20675 if (temp2)
20676 delete arg2;
20677 }
20678 return NULL;
20679 }
20680
20681
20682 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20683 PyObject *resultobj = 0;
20684 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20685 wxString *arg2 = 0 ;
20686 bool arg3 ;
20687 bool result;
20688 void *argp1 = 0 ;
20689 int res1 = 0 ;
20690 bool temp2 = false ;
20691 bool val3 ;
20692 int ecode3 = 0 ;
20693 PyObject * obj0 = 0 ;
20694 PyObject * obj1 = 0 ;
20695 PyObject * obj2 = 0 ;
20696 char * kwnames[] = {
20697 (char *) "self",(char *) "key",(char *) "value", NULL
20698 };
20699
20700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20704 }
20705 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20706 {
20707 arg2 = wxString_in_helper(obj1);
20708 if (arg2 == NULL) SWIG_fail;
20709 temp2 = true;
20710 }
20711 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20712 if (!SWIG_IsOK(ecode3)) {
20713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20714 }
20715 arg3 = static_cast< bool >(val3);
20716 {
20717 PyThreadState* __tstate = wxPyBeginAllowThreads();
20718 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20719 wxPyEndAllowThreads(__tstate);
20720 if (PyErr_Occurred()) SWIG_fail;
20721 }
20722 {
20723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20724 }
20725 {
20726 if (temp2)
20727 delete arg2;
20728 }
20729 return resultobj;
20730 fail:
20731 {
20732 if (temp2)
20733 delete arg2;
20734 }
20735 return NULL;
20736 }
20737
20738
20739 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20740 PyObject *resultobj = 0;
20741 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20742 bool arg2 = (bool) false ;
20743 bool result;
20744 void *argp1 = 0 ;
20745 int res1 = 0 ;
20746 bool val2 ;
20747 int ecode2 = 0 ;
20748 PyObject * obj0 = 0 ;
20749 PyObject * obj1 = 0 ;
20750 char * kwnames[] = {
20751 (char *) "self",(char *) "currentOnly", NULL
20752 };
20753
20754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20756 if (!SWIG_IsOK(res1)) {
20757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20758 }
20759 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20760 if (obj1) {
20761 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20762 if (!SWIG_IsOK(ecode2)) {
20763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20764 }
20765 arg2 = static_cast< bool >(val2);
20766 }
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 result = (bool)(arg1)->Flush(arg2);
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 {
20774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20775 }
20776 return resultobj;
20777 fail:
20778 return NULL;
20779 }
20780
20781
20782 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20783 PyObject *resultobj = 0;
20784 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20785 wxString *arg2 = 0 ;
20786 wxString *arg3 = 0 ;
20787 bool result;
20788 void *argp1 = 0 ;
20789 int res1 = 0 ;
20790 bool temp2 = false ;
20791 bool temp3 = false ;
20792 PyObject * obj0 = 0 ;
20793 PyObject * obj1 = 0 ;
20794 PyObject * obj2 = 0 ;
20795 char * kwnames[] = {
20796 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20797 };
20798
20799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20801 if (!SWIG_IsOK(res1)) {
20802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20803 }
20804 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20805 {
20806 arg2 = wxString_in_helper(obj1);
20807 if (arg2 == NULL) SWIG_fail;
20808 temp2 = true;
20809 }
20810 {
20811 arg3 = wxString_in_helper(obj2);
20812 if (arg3 == NULL) SWIG_fail;
20813 temp3 = true;
20814 }
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 {
20822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20823 }
20824 {
20825 if (temp2)
20826 delete arg2;
20827 }
20828 {
20829 if (temp3)
20830 delete arg3;
20831 }
20832 return resultobj;
20833 fail:
20834 {
20835 if (temp2)
20836 delete arg2;
20837 }
20838 {
20839 if (temp3)
20840 delete arg3;
20841 }
20842 return NULL;
20843 }
20844
20845
20846 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20847 PyObject *resultobj = 0;
20848 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20849 wxString *arg2 = 0 ;
20850 wxString *arg3 = 0 ;
20851 bool result;
20852 void *argp1 = 0 ;
20853 int res1 = 0 ;
20854 bool temp2 = false ;
20855 bool temp3 = false ;
20856 PyObject * obj0 = 0 ;
20857 PyObject * obj1 = 0 ;
20858 PyObject * obj2 = 0 ;
20859 char * kwnames[] = {
20860 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20861 };
20862
20863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20867 }
20868 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20869 {
20870 arg2 = wxString_in_helper(obj1);
20871 if (arg2 == NULL) SWIG_fail;
20872 temp2 = true;
20873 }
20874 {
20875 arg3 = wxString_in_helper(obj2);
20876 if (arg3 == NULL) SWIG_fail;
20877 temp3 = true;
20878 }
20879 {
20880 PyThreadState* __tstate = wxPyBeginAllowThreads();
20881 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 {
20886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20887 }
20888 {
20889 if (temp2)
20890 delete arg2;
20891 }
20892 {
20893 if (temp3)
20894 delete arg3;
20895 }
20896 return resultobj;
20897 fail:
20898 {
20899 if (temp2)
20900 delete arg2;
20901 }
20902 {
20903 if (temp3)
20904 delete arg3;
20905 }
20906 return NULL;
20907 }
20908
20909
20910 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20911 PyObject *resultobj = 0;
20912 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20913 wxString *arg2 = 0 ;
20914 bool arg3 = (bool) true ;
20915 bool result;
20916 void *argp1 = 0 ;
20917 int res1 = 0 ;
20918 bool temp2 = false ;
20919 bool val3 ;
20920 int ecode3 = 0 ;
20921 PyObject * obj0 = 0 ;
20922 PyObject * obj1 = 0 ;
20923 PyObject * obj2 = 0 ;
20924 char * kwnames[] = {
20925 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20926 };
20927
20928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20930 if (!SWIG_IsOK(res1)) {
20931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20932 }
20933 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20934 {
20935 arg2 = wxString_in_helper(obj1);
20936 if (arg2 == NULL) SWIG_fail;
20937 temp2 = true;
20938 }
20939 if (obj2) {
20940 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20941 if (!SWIG_IsOK(ecode3)) {
20942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20943 }
20944 arg3 = static_cast< bool >(val3);
20945 }
20946 {
20947 PyThreadState* __tstate = wxPyBeginAllowThreads();
20948 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20949 wxPyEndAllowThreads(__tstate);
20950 if (PyErr_Occurred()) SWIG_fail;
20951 }
20952 {
20953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20954 }
20955 {
20956 if (temp2)
20957 delete arg2;
20958 }
20959 return resultobj;
20960 fail:
20961 {
20962 if (temp2)
20963 delete arg2;
20964 }
20965 return NULL;
20966 }
20967
20968
20969 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20970 PyObject *resultobj = 0;
20971 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20972 wxString *arg2 = 0 ;
20973 bool result;
20974 void *argp1 = 0 ;
20975 int res1 = 0 ;
20976 bool temp2 = false ;
20977 PyObject * obj0 = 0 ;
20978 PyObject * obj1 = 0 ;
20979 char * kwnames[] = {
20980 (char *) "self",(char *) "key", NULL
20981 };
20982
20983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20985 if (!SWIG_IsOK(res1)) {
20986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20987 }
20988 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20989 {
20990 arg2 = wxString_in_helper(obj1);
20991 if (arg2 == NULL) SWIG_fail;
20992 temp2 = true;
20993 }
20994 {
20995 PyThreadState* __tstate = wxPyBeginAllowThreads();
20996 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 {
21001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21002 }
21003 {
21004 if (temp2)
21005 delete arg2;
21006 }
21007 return resultobj;
21008 fail:
21009 {
21010 if (temp2)
21011 delete arg2;
21012 }
21013 return NULL;
21014 }
21015
21016
21017 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21018 PyObject *resultobj = 0;
21019 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21020 bool result;
21021 void *argp1 = 0 ;
21022 int res1 = 0 ;
21023 PyObject *swig_obj[1] ;
21024
21025 if (!args) SWIG_fail;
21026 swig_obj[0] = args;
21027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21028 if (!SWIG_IsOK(res1)) {
21029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21030 }
21031 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 result = (bool)(arg1)->DeleteAll();
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 {
21039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21040 }
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21048 PyObject *resultobj = 0;
21049 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21050 bool arg2 = (bool) true ;
21051 void *argp1 = 0 ;
21052 int res1 = 0 ;
21053 bool val2 ;
21054 int ecode2 = 0 ;
21055 PyObject * obj0 = 0 ;
21056 PyObject * obj1 = 0 ;
21057 char * kwnames[] = {
21058 (char *) "self",(char *) "doIt", NULL
21059 };
21060
21061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21063 if (!SWIG_IsOK(res1)) {
21064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21065 }
21066 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21067 if (obj1) {
21068 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21069 if (!SWIG_IsOK(ecode2)) {
21070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
21071 }
21072 arg2 = static_cast< bool >(val2);
21073 }
21074 {
21075 PyThreadState* __tstate = wxPyBeginAllowThreads();
21076 (arg1)->SetExpandEnvVars(arg2);
21077 wxPyEndAllowThreads(__tstate);
21078 if (PyErr_Occurred()) SWIG_fail;
21079 }
21080 resultobj = SWIG_Py_Void();
21081 return resultobj;
21082 fail:
21083 return NULL;
21084 }
21085
21086
21087 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21088 PyObject *resultobj = 0;
21089 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21090 bool result;
21091 void *argp1 = 0 ;
21092 int res1 = 0 ;
21093 PyObject *swig_obj[1] ;
21094
21095 if (!args) SWIG_fail;
21096 swig_obj[0] = args;
21097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21098 if (!SWIG_IsOK(res1)) {
21099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21100 }
21101 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
21105 wxPyEndAllowThreads(__tstate);
21106 if (PyErr_Occurred()) SWIG_fail;
21107 }
21108 {
21109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21110 }
21111 return resultobj;
21112 fail:
21113 return NULL;
21114 }
21115
21116
21117 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21118 PyObject *resultobj = 0;
21119 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21120 bool arg2 = (bool) true ;
21121 void *argp1 = 0 ;
21122 int res1 = 0 ;
21123 bool val2 ;
21124 int ecode2 = 0 ;
21125 PyObject * obj0 = 0 ;
21126 PyObject * obj1 = 0 ;
21127 char * kwnames[] = {
21128 (char *) "self",(char *) "doIt", NULL
21129 };
21130
21131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21135 }
21136 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21137 if (obj1) {
21138 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21139 if (!SWIG_IsOK(ecode2)) {
21140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21141 }
21142 arg2 = static_cast< bool >(val2);
21143 }
21144 {
21145 PyThreadState* __tstate = wxPyBeginAllowThreads();
21146 (arg1)->SetRecordDefaults(arg2);
21147 wxPyEndAllowThreads(__tstate);
21148 if (PyErr_Occurred()) SWIG_fail;
21149 }
21150 resultobj = SWIG_Py_Void();
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21158 PyObject *resultobj = 0;
21159 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21160 bool result;
21161 void *argp1 = 0 ;
21162 int res1 = 0 ;
21163 PyObject *swig_obj[1] ;
21164
21165 if (!args) SWIG_fail;
21166 swig_obj[0] = args;
21167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21168 if (!SWIG_IsOK(res1)) {
21169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21170 }
21171 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21172 {
21173 PyThreadState* __tstate = wxPyBeginAllowThreads();
21174 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 {
21179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21180 }
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21188 PyObject *resultobj = 0;
21189 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21190 wxString *arg2 = 0 ;
21191 wxString result;
21192 void *argp1 = 0 ;
21193 int res1 = 0 ;
21194 bool temp2 = false ;
21195 PyObject * obj0 = 0 ;
21196 PyObject * obj1 = 0 ;
21197 char * kwnames[] = {
21198 (char *) "self",(char *) "str", NULL
21199 };
21200
21201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21203 if (!SWIG_IsOK(res1)) {
21204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21205 }
21206 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21207 {
21208 arg2 = wxString_in_helper(obj1);
21209 if (arg2 == NULL) SWIG_fail;
21210 temp2 = true;
21211 }
21212 {
21213 PyThreadState* __tstate = wxPyBeginAllowThreads();
21214 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21215 wxPyEndAllowThreads(__tstate);
21216 if (PyErr_Occurred()) SWIG_fail;
21217 }
21218 {
21219 #if wxUSE_UNICODE
21220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21221 #else
21222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21223 #endif
21224 }
21225 {
21226 if (temp2)
21227 delete arg2;
21228 }
21229 return resultobj;
21230 fail:
21231 {
21232 if (temp2)
21233 delete arg2;
21234 }
21235 return NULL;
21236 }
21237
21238
21239 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21240 PyObject *resultobj = 0;
21241 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21242 wxString result;
21243 void *argp1 = 0 ;
21244 int res1 = 0 ;
21245 PyObject *swig_obj[1] ;
21246
21247 if (!args) SWIG_fail;
21248 swig_obj[0] = args;
21249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21250 if (!SWIG_IsOK(res1)) {
21251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21252 }
21253 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21254 {
21255 PyThreadState* __tstate = wxPyBeginAllowThreads();
21256 result = ((wxConfigBase const *)arg1)->GetAppName();
21257 wxPyEndAllowThreads(__tstate);
21258 if (PyErr_Occurred()) SWIG_fail;
21259 }
21260 {
21261 #if wxUSE_UNICODE
21262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21263 #else
21264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21265 #endif
21266 }
21267 return resultobj;
21268 fail:
21269 return NULL;
21270 }
21271
21272
21273 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21274 PyObject *resultobj = 0;
21275 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21276 wxString result;
21277 void *argp1 = 0 ;
21278 int res1 = 0 ;
21279 PyObject *swig_obj[1] ;
21280
21281 if (!args) SWIG_fail;
21282 swig_obj[0] = args;
21283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21284 if (!SWIG_IsOK(res1)) {
21285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21286 }
21287 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21288 {
21289 PyThreadState* __tstate = wxPyBeginAllowThreads();
21290 result = ((wxConfigBase const *)arg1)->GetVendorName();
21291 wxPyEndAllowThreads(__tstate);
21292 if (PyErr_Occurred()) SWIG_fail;
21293 }
21294 {
21295 #if wxUSE_UNICODE
21296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21297 #else
21298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21299 #endif
21300 }
21301 return resultobj;
21302 fail:
21303 return NULL;
21304 }
21305
21306
21307 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21308 PyObject *resultobj = 0;
21309 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21310 wxString *arg2 = 0 ;
21311 void *argp1 = 0 ;
21312 int res1 = 0 ;
21313 bool temp2 = false ;
21314 PyObject * obj0 = 0 ;
21315 PyObject * obj1 = 0 ;
21316 char * kwnames[] = {
21317 (char *) "self",(char *) "appName", NULL
21318 };
21319
21320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21322 if (!SWIG_IsOK(res1)) {
21323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21324 }
21325 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21326 {
21327 arg2 = wxString_in_helper(obj1);
21328 if (arg2 == NULL) SWIG_fail;
21329 temp2 = true;
21330 }
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 (arg1)->SetAppName((wxString const &)*arg2);
21334 wxPyEndAllowThreads(__tstate);
21335 if (PyErr_Occurred()) SWIG_fail;
21336 }
21337 resultobj = SWIG_Py_Void();
21338 {
21339 if (temp2)
21340 delete arg2;
21341 }
21342 return resultobj;
21343 fail:
21344 {
21345 if (temp2)
21346 delete arg2;
21347 }
21348 return NULL;
21349 }
21350
21351
21352 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21353 PyObject *resultobj = 0;
21354 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21355 wxString *arg2 = 0 ;
21356 void *argp1 = 0 ;
21357 int res1 = 0 ;
21358 bool temp2 = false ;
21359 PyObject * obj0 = 0 ;
21360 PyObject * obj1 = 0 ;
21361 char * kwnames[] = {
21362 (char *) "self",(char *) "vendorName", NULL
21363 };
21364
21365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21367 if (!SWIG_IsOK(res1)) {
21368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21369 }
21370 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21371 {
21372 arg2 = wxString_in_helper(obj1);
21373 if (arg2 == NULL) SWIG_fail;
21374 temp2 = true;
21375 }
21376 {
21377 PyThreadState* __tstate = wxPyBeginAllowThreads();
21378 (arg1)->SetVendorName((wxString const &)*arg2);
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 resultobj = SWIG_Py_Void();
21383 {
21384 if (temp2)
21385 delete arg2;
21386 }
21387 return resultobj;
21388 fail:
21389 {
21390 if (temp2)
21391 delete arg2;
21392 }
21393 return NULL;
21394 }
21395
21396
21397 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj = 0;
21399 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21400 long arg2 ;
21401 void *argp1 = 0 ;
21402 int res1 = 0 ;
21403 long val2 ;
21404 int ecode2 = 0 ;
21405 PyObject * obj0 = 0 ;
21406 PyObject * obj1 = 0 ;
21407 char * kwnames[] = {
21408 (char *) "self",(char *) "style", NULL
21409 };
21410
21411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21413 if (!SWIG_IsOK(res1)) {
21414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21415 }
21416 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21417 ecode2 = SWIG_AsVal_long(obj1, &val2);
21418 if (!SWIG_IsOK(ecode2)) {
21419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21420 }
21421 arg2 = static_cast< long >(val2);
21422 {
21423 PyThreadState* __tstate = wxPyBeginAllowThreads();
21424 (arg1)->SetStyle(arg2);
21425 wxPyEndAllowThreads(__tstate);
21426 if (PyErr_Occurred()) SWIG_fail;
21427 }
21428 resultobj = SWIG_Py_Void();
21429 return resultobj;
21430 fail:
21431 return NULL;
21432 }
21433
21434
21435 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21436 PyObject *resultobj = 0;
21437 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21438 long result;
21439 void *argp1 = 0 ;
21440 int res1 = 0 ;
21441 PyObject *swig_obj[1] ;
21442
21443 if (!args) SWIG_fail;
21444 swig_obj[0] = args;
21445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21446 if (!SWIG_IsOK(res1)) {
21447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21448 }
21449 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21450 {
21451 PyThreadState* __tstate = wxPyBeginAllowThreads();
21452 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21453 wxPyEndAllowThreads(__tstate);
21454 if (PyErr_Occurred()) SWIG_fail;
21455 }
21456 resultobj = SWIG_From_long(static_cast< long >(result));
21457 return resultobj;
21458 fail:
21459 return NULL;
21460 }
21461
21462
21463 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21464 PyObject *obj;
21465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21466 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21467 return SWIG_Py_Void();
21468 }
21469
21470 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21471 PyObject *resultobj = 0;
21472 wxString const &arg1_defvalue = wxPyEmptyString ;
21473 wxString *arg1 = (wxString *) &arg1_defvalue ;
21474 wxString const &arg2_defvalue = wxPyEmptyString ;
21475 wxString *arg2 = (wxString *) &arg2_defvalue ;
21476 wxString const &arg3_defvalue = wxPyEmptyString ;
21477 wxString *arg3 = (wxString *) &arg3_defvalue ;
21478 wxString const &arg4_defvalue = wxPyEmptyString ;
21479 wxString *arg4 = (wxString *) &arg4_defvalue ;
21480 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21481 wxConfig *result = 0 ;
21482 bool temp1 = false ;
21483 bool temp2 = false ;
21484 bool temp3 = false ;
21485 bool temp4 = false ;
21486 long val5 ;
21487 int ecode5 = 0 ;
21488 PyObject * obj0 = 0 ;
21489 PyObject * obj1 = 0 ;
21490 PyObject * obj2 = 0 ;
21491 PyObject * obj3 = 0 ;
21492 PyObject * obj4 = 0 ;
21493 char * kwnames[] = {
21494 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21495 };
21496
21497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21498 if (obj0) {
21499 {
21500 arg1 = wxString_in_helper(obj0);
21501 if (arg1 == NULL) SWIG_fail;
21502 temp1 = true;
21503 }
21504 }
21505 if (obj1) {
21506 {
21507 arg2 = wxString_in_helper(obj1);
21508 if (arg2 == NULL) SWIG_fail;
21509 temp2 = true;
21510 }
21511 }
21512 if (obj2) {
21513 {
21514 arg3 = wxString_in_helper(obj2);
21515 if (arg3 == NULL) SWIG_fail;
21516 temp3 = true;
21517 }
21518 }
21519 if (obj3) {
21520 {
21521 arg4 = wxString_in_helper(obj3);
21522 if (arg4 == NULL) SWIG_fail;
21523 temp4 = true;
21524 }
21525 }
21526 if (obj4) {
21527 ecode5 = SWIG_AsVal_long(obj4, &val5);
21528 if (!SWIG_IsOK(ecode5)) {
21529 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21530 }
21531 arg5 = static_cast< long >(val5);
21532 }
21533 {
21534 PyThreadState* __tstate = wxPyBeginAllowThreads();
21535 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21536 wxPyEndAllowThreads(__tstate);
21537 if (PyErr_Occurred()) SWIG_fail;
21538 }
21539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21540 {
21541 if (temp1)
21542 delete arg1;
21543 }
21544 {
21545 if (temp2)
21546 delete arg2;
21547 }
21548 {
21549 if (temp3)
21550 delete arg3;
21551 }
21552 {
21553 if (temp4)
21554 delete arg4;
21555 }
21556 return resultobj;
21557 fail:
21558 {
21559 if (temp1)
21560 delete arg1;
21561 }
21562 {
21563 if (temp2)
21564 delete arg2;
21565 }
21566 {
21567 if (temp3)
21568 delete arg3;
21569 }
21570 {
21571 if (temp4)
21572 delete arg4;
21573 }
21574 return NULL;
21575 }
21576
21577
21578 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21579 PyObject *resultobj = 0;
21580 wxConfig *arg1 = (wxConfig *) 0 ;
21581 void *argp1 = 0 ;
21582 int res1 = 0 ;
21583 PyObject *swig_obj[1] ;
21584
21585 if (!args) SWIG_fail;
21586 swig_obj[0] = args;
21587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21588 if (!SWIG_IsOK(res1)) {
21589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21590 }
21591 arg1 = reinterpret_cast< wxConfig * >(argp1);
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 delete arg1;
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 resultobj = SWIG_Py_Void();
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21607 PyObject *obj;
21608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21609 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21610 return SWIG_Py_Void();
21611 }
21612
21613 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21614 return SWIG_Python_InitShadowInstance(args);
21615 }
21616
21617 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21618 PyObject *resultobj = 0;
21619 wxString const &arg1_defvalue = wxPyEmptyString ;
21620 wxString *arg1 = (wxString *) &arg1_defvalue ;
21621 wxString const &arg2_defvalue = wxPyEmptyString ;
21622 wxString *arg2 = (wxString *) &arg2_defvalue ;
21623 wxString const &arg3_defvalue = wxPyEmptyString ;
21624 wxString *arg3 = (wxString *) &arg3_defvalue ;
21625 wxString const &arg4_defvalue = wxPyEmptyString ;
21626 wxString *arg4 = (wxString *) &arg4_defvalue ;
21627 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21628 wxFileConfig *result = 0 ;
21629 bool temp1 = false ;
21630 bool temp2 = false ;
21631 bool temp3 = false ;
21632 bool temp4 = false ;
21633 long val5 ;
21634 int ecode5 = 0 ;
21635 PyObject * obj0 = 0 ;
21636 PyObject * obj1 = 0 ;
21637 PyObject * obj2 = 0 ;
21638 PyObject * obj3 = 0 ;
21639 PyObject * obj4 = 0 ;
21640 char * kwnames[] = {
21641 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21642 };
21643
21644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21645 if (obj0) {
21646 {
21647 arg1 = wxString_in_helper(obj0);
21648 if (arg1 == NULL) SWIG_fail;
21649 temp1 = true;
21650 }
21651 }
21652 if (obj1) {
21653 {
21654 arg2 = wxString_in_helper(obj1);
21655 if (arg2 == NULL) SWIG_fail;
21656 temp2 = true;
21657 }
21658 }
21659 if (obj2) {
21660 {
21661 arg3 = wxString_in_helper(obj2);
21662 if (arg3 == NULL) SWIG_fail;
21663 temp3 = true;
21664 }
21665 }
21666 if (obj3) {
21667 {
21668 arg4 = wxString_in_helper(obj3);
21669 if (arg4 == NULL) SWIG_fail;
21670 temp4 = true;
21671 }
21672 }
21673 if (obj4) {
21674 ecode5 = SWIG_AsVal_long(obj4, &val5);
21675 if (!SWIG_IsOK(ecode5)) {
21676 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21677 }
21678 arg5 = static_cast< long >(val5);
21679 }
21680 {
21681 PyThreadState* __tstate = wxPyBeginAllowThreads();
21682 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21687 {
21688 if (temp1)
21689 delete arg1;
21690 }
21691 {
21692 if (temp2)
21693 delete arg2;
21694 }
21695 {
21696 if (temp3)
21697 delete arg3;
21698 }
21699 {
21700 if (temp4)
21701 delete arg4;
21702 }
21703 return resultobj;
21704 fail:
21705 {
21706 if (temp1)
21707 delete arg1;
21708 }
21709 {
21710 if (temp2)
21711 delete arg2;
21712 }
21713 {
21714 if (temp3)
21715 delete arg3;
21716 }
21717 {
21718 if (temp4)
21719 delete arg4;
21720 }
21721 return NULL;
21722 }
21723
21724
21725 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21726 PyObject *resultobj = 0;
21727 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21728 void *argp1 = 0 ;
21729 int res1 = 0 ;
21730 PyObject *swig_obj[1] ;
21731
21732 if (!args) SWIG_fail;
21733 swig_obj[0] = args;
21734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21735 if (!SWIG_IsOK(res1)) {
21736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21737 }
21738 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21739 {
21740 PyThreadState* __tstate = wxPyBeginAllowThreads();
21741 delete arg1;
21742
21743 wxPyEndAllowThreads(__tstate);
21744 if (PyErr_Occurred()) SWIG_fail;
21745 }
21746 resultobj = SWIG_Py_Void();
21747 return resultobj;
21748 fail:
21749 return NULL;
21750 }
21751
21752
21753 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21754 PyObject *obj;
21755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21756 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21757 return SWIG_Py_Void();
21758 }
21759
21760 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21761 return SWIG_Python_InitShadowInstance(args);
21762 }
21763
21764 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21765 PyObject *resultobj = 0;
21766 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21767 wxString *arg2 = 0 ;
21768 wxConfigPathChanger *result = 0 ;
21769 void *argp1 = 0 ;
21770 int res1 = 0 ;
21771 bool temp2 = false ;
21772 PyObject * obj0 = 0 ;
21773 PyObject * obj1 = 0 ;
21774 char * kwnames[] = {
21775 (char *) "config",(char *) "entry", NULL
21776 };
21777
21778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21780 if (!SWIG_IsOK(res1)) {
21781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21782 }
21783 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21784 {
21785 arg2 = wxString_in_helper(obj1);
21786 if (arg2 == NULL) SWIG_fail;
21787 temp2 = true;
21788 }
21789 {
21790 PyThreadState* __tstate = wxPyBeginAllowThreads();
21791 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21792 wxPyEndAllowThreads(__tstate);
21793 if (PyErr_Occurred()) SWIG_fail;
21794 }
21795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21796 {
21797 if (temp2)
21798 delete arg2;
21799 }
21800 return resultobj;
21801 fail:
21802 {
21803 if (temp2)
21804 delete arg2;
21805 }
21806 return NULL;
21807 }
21808
21809
21810 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21811 PyObject *resultobj = 0;
21812 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21813 void *argp1 = 0 ;
21814 int res1 = 0 ;
21815 PyObject *swig_obj[1] ;
21816
21817 if (!args) SWIG_fail;
21818 swig_obj[0] = args;
21819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21820 if (!SWIG_IsOK(res1)) {
21821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21822 }
21823 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21824 {
21825 PyThreadState* __tstate = wxPyBeginAllowThreads();
21826 delete arg1;
21827
21828 wxPyEndAllowThreads(__tstate);
21829 if (PyErr_Occurred()) SWIG_fail;
21830 }
21831 resultobj = SWIG_Py_Void();
21832 return resultobj;
21833 fail:
21834 return NULL;
21835 }
21836
21837
21838 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21839 PyObject *resultobj = 0;
21840 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21841 wxString *result = 0 ;
21842 void *argp1 = 0 ;
21843 int res1 = 0 ;
21844 PyObject *swig_obj[1] ;
21845
21846 if (!args) SWIG_fail;
21847 swig_obj[0] = args;
21848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21849 if (!SWIG_IsOK(res1)) {
21850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21851 }
21852 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21853 {
21854 PyThreadState* __tstate = wxPyBeginAllowThreads();
21855 {
21856 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21857 result = (wxString *) &_result_ref;
21858 }
21859 wxPyEndAllowThreads(__tstate);
21860 if (PyErr_Occurred()) SWIG_fail;
21861 }
21862 {
21863 #if wxUSE_UNICODE
21864 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21865 #else
21866 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21867 #endif
21868 }
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21876 PyObject *obj;
21877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21878 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21879 return SWIG_Py_Void();
21880 }
21881
21882 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21883 return SWIG_Python_InitShadowInstance(args);
21884 }
21885
21886 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21887 PyObject *resultobj = 0;
21888 wxString *arg1 = 0 ;
21889 wxString result;
21890 bool temp1 = false ;
21891 PyObject * obj0 = 0 ;
21892 char * kwnames[] = {
21893 (char *) "sz", NULL
21894 };
21895
21896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21897 {
21898 arg1 = wxString_in_helper(obj0);
21899 if (arg1 == NULL) SWIG_fail;
21900 temp1 = true;
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 result = wxExpandEnvVars((wxString const &)*arg1);
21905 wxPyEndAllowThreads(__tstate);
21906 if (PyErr_Occurred()) SWIG_fail;
21907 }
21908 {
21909 #if wxUSE_UNICODE
21910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21911 #else
21912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21913 #endif
21914 }
21915 {
21916 if (temp1)
21917 delete arg1;
21918 }
21919 return resultobj;
21920 fail:
21921 {
21922 if (temp1)
21923 delete arg1;
21924 }
21925 return NULL;
21926 }
21927
21928
21929 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21930 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21931 return 1;
21932 }
21933
21934
21935 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21936 PyObject *pyobj = 0;
21937
21938 {
21939 #if wxUSE_UNICODE
21940 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21941 #else
21942 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21943 #endif
21944 }
21945 return pyobj;
21946 }
21947
21948
21949 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21950 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21951 return 1;
21952 }
21953
21954
21955 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21956 PyObject *pyobj = 0;
21957
21958 {
21959 #if wxUSE_UNICODE
21960 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21961 #else
21962 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21963 #endif
21964 }
21965 return pyobj;
21966 }
21967
21968
21969 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21970 PyObject *resultobj = 0;
21971 wxDateTime::Country arg1 ;
21972 int val1 ;
21973 int ecode1 = 0 ;
21974 PyObject * obj0 = 0 ;
21975 char * kwnames[] = {
21976 (char *) "country", NULL
21977 };
21978
21979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21980 ecode1 = SWIG_AsVal_int(obj0, &val1);
21981 if (!SWIG_IsOK(ecode1)) {
21982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21983 }
21984 arg1 = static_cast< wxDateTime::Country >(val1);
21985 {
21986 PyThreadState* __tstate = wxPyBeginAllowThreads();
21987 wxDateTime::SetCountry(arg1);
21988 wxPyEndAllowThreads(__tstate);
21989 if (PyErr_Occurred()) SWIG_fail;
21990 }
21991 resultobj = SWIG_Py_Void();
21992 return resultobj;
21993 fail:
21994 return NULL;
21995 }
21996
21997
21998 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21999 PyObject *resultobj = 0;
22000 wxDateTime::Country result;
22001
22002 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22003 {
22004 PyThreadState* __tstate = wxPyBeginAllowThreads();
22005 result = (wxDateTime::Country)wxDateTime::GetCountry();
22006 wxPyEndAllowThreads(__tstate);
22007 if (PyErr_Occurred()) SWIG_fail;
22008 }
22009 resultobj = SWIG_From_int(static_cast< int >(result));
22010 return resultobj;
22011 fail:
22012 return NULL;
22013 }
22014
22015
22016 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22017 PyObject *resultobj = 0;
22018 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22019 bool result;
22020 int val1 ;
22021 int ecode1 = 0 ;
22022 PyObject * obj0 = 0 ;
22023 char * kwnames[] = {
22024 (char *) "country", NULL
22025 };
22026
22027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22028 if (obj0) {
22029 ecode1 = SWIG_AsVal_int(obj0, &val1);
22030 if (!SWIG_IsOK(ecode1)) {
22031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22032 }
22033 arg1 = static_cast< wxDateTime::Country >(val1);
22034 }
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 {
22042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22043 }
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj = 0;
22052 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22053 int result;
22054 int val1 ;
22055 int ecode1 = 0 ;
22056 PyObject * obj0 = 0 ;
22057 char * kwnames[] = {
22058 (char *) "cal", NULL
22059 };
22060
22061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
22062 if (obj0) {
22063 ecode1 = SWIG_AsVal_int(obj0, &val1);
22064 if (!SWIG_IsOK(ecode1)) {
22065 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22066 }
22067 arg1 = static_cast< wxDateTime::Calendar >(val1);
22068 }
22069 {
22070 PyThreadState* __tstate = wxPyBeginAllowThreads();
22071 result = (int)wxDateTime::GetCurrentYear(arg1);
22072 wxPyEndAllowThreads(__tstate);
22073 if (PyErr_Occurred()) SWIG_fail;
22074 }
22075 resultobj = SWIG_From_int(static_cast< int >(result));
22076 return resultobj;
22077 fail:
22078 return NULL;
22079 }
22080
22081
22082 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22083 PyObject *resultobj = 0;
22084 int arg1 ;
22085 int result;
22086 int val1 ;
22087 int ecode1 = 0 ;
22088 PyObject * obj0 = 0 ;
22089 char * kwnames[] = {
22090 (char *) "year", NULL
22091 };
22092
22093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
22094 ecode1 = SWIG_AsVal_int(obj0, &val1);
22095 if (!SWIG_IsOK(ecode1)) {
22096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
22097 }
22098 arg1 = static_cast< int >(val1);
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (int)wxDateTime::ConvertYearToBC(arg1);
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 resultobj = SWIG_From_int(static_cast< int >(result));
22106 return resultobj;
22107 fail:
22108 return NULL;
22109 }
22110
22111
22112 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22113 PyObject *resultobj = 0;
22114 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22115 wxDateTime::Month result;
22116 int val1 ;
22117 int ecode1 = 0 ;
22118 PyObject * obj0 = 0 ;
22119 char * kwnames[] = {
22120 (char *) "cal", NULL
22121 };
22122
22123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22124 if (obj0) {
22125 ecode1 = SWIG_AsVal_int(obj0, &val1);
22126 if (!SWIG_IsOK(ecode1)) {
22127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22128 }
22129 arg1 = static_cast< wxDateTime::Calendar >(val1);
22130 }
22131 {
22132 PyThreadState* __tstate = wxPyBeginAllowThreads();
22133 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22134 wxPyEndAllowThreads(__tstate);
22135 if (PyErr_Occurred()) SWIG_fail;
22136 }
22137 resultobj = SWIG_From_int(static_cast< int >(result));
22138 return resultobj;
22139 fail:
22140 return NULL;
22141 }
22142
22143
22144 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22145 PyObject *resultobj = 0;
22146 int arg1 = (int) wxDateTime::Inv_Year ;
22147 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22148 bool result;
22149 int val1 ;
22150 int ecode1 = 0 ;
22151 int val2 ;
22152 int ecode2 = 0 ;
22153 PyObject * obj0 = 0 ;
22154 PyObject * obj1 = 0 ;
22155 char * kwnames[] = {
22156 (char *) "year",(char *) "cal", NULL
22157 };
22158
22159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22160 if (obj0) {
22161 ecode1 = SWIG_AsVal_int(obj0, &val1);
22162 if (!SWIG_IsOK(ecode1)) {
22163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22164 }
22165 arg1 = static_cast< int >(val1);
22166 }
22167 if (obj1) {
22168 ecode2 = SWIG_AsVal_int(obj1, &val2);
22169 if (!SWIG_IsOK(ecode2)) {
22170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22171 }
22172 arg2 = static_cast< wxDateTime::Calendar >(val2);
22173 }
22174 {
22175 PyThreadState* __tstate = wxPyBeginAllowThreads();
22176 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22177 wxPyEndAllowThreads(__tstate);
22178 if (PyErr_Occurred()) SWIG_fail;
22179 }
22180 {
22181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22182 }
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj = 0;
22191 int arg1 = (int) wxDateTime::Inv_Year ;
22192 int result;
22193 int val1 ;
22194 int ecode1 = 0 ;
22195 PyObject * obj0 = 0 ;
22196 char * kwnames[] = {
22197 (char *) "year", NULL
22198 };
22199
22200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22201 if (obj0) {
22202 ecode1 = SWIG_AsVal_int(obj0, &val1);
22203 if (!SWIG_IsOK(ecode1)) {
22204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22205 }
22206 arg1 = static_cast< int >(val1);
22207 }
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 result = (int)wxDateTime::GetCentury(arg1);
22211 wxPyEndAllowThreads(__tstate);
22212 if (PyErr_Occurred()) SWIG_fail;
22213 }
22214 resultobj = SWIG_From_int(static_cast< int >(result));
22215 return resultobj;
22216 fail:
22217 return NULL;
22218 }
22219
22220
22221 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22222 PyObject *resultobj = 0;
22223 int arg1 ;
22224 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22225 int result;
22226 int val1 ;
22227 int ecode1 = 0 ;
22228 int val2 ;
22229 int ecode2 = 0 ;
22230 PyObject * obj0 = 0 ;
22231 PyObject * obj1 = 0 ;
22232 char * kwnames[] = {
22233 (char *) "year",(char *) "cal", NULL
22234 };
22235
22236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22237 ecode1 = SWIG_AsVal_int(obj0, &val1);
22238 if (!SWIG_IsOK(ecode1)) {
22239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22240 }
22241 arg1 = static_cast< int >(val1);
22242 if (obj1) {
22243 ecode2 = SWIG_AsVal_int(obj1, &val2);
22244 if (!SWIG_IsOK(ecode2)) {
22245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22246 }
22247 arg2 = static_cast< wxDateTime::Calendar >(val2);
22248 }
22249 {
22250 PyThreadState* __tstate = wxPyBeginAllowThreads();
22251 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22252 wxPyEndAllowThreads(__tstate);
22253 if (PyErr_Occurred()) SWIG_fail;
22254 }
22255 resultobj = SWIG_From_int(static_cast< int >(result));
22256 return resultobj;
22257 fail:
22258 return NULL;
22259 }
22260
22261
22262 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22263 PyObject *resultobj = 0;
22264 wxDateTime::Month arg1 ;
22265 int arg2 = (int) wxDateTime::Inv_Year ;
22266 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22267 int result;
22268 int val1 ;
22269 int ecode1 = 0 ;
22270 int val2 ;
22271 int ecode2 = 0 ;
22272 int val3 ;
22273 int ecode3 = 0 ;
22274 PyObject * obj0 = 0 ;
22275 PyObject * obj1 = 0 ;
22276 PyObject * obj2 = 0 ;
22277 char * kwnames[] = {
22278 (char *) "month",(char *) "year",(char *) "cal", NULL
22279 };
22280
22281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22282 ecode1 = SWIG_AsVal_int(obj0, &val1);
22283 if (!SWIG_IsOK(ecode1)) {
22284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22285 }
22286 arg1 = static_cast< wxDateTime::Month >(val1);
22287 if (obj1) {
22288 ecode2 = SWIG_AsVal_int(obj1, &val2);
22289 if (!SWIG_IsOK(ecode2)) {
22290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22291 }
22292 arg2 = static_cast< int >(val2);
22293 }
22294 if (obj2) {
22295 ecode3 = SWIG_AsVal_int(obj2, &val3);
22296 if (!SWIG_IsOK(ecode3)) {
22297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22298 }
22299 arg3 = static_cast< wxDateTime::Calendar >(val3);
22300 }
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 resultobj = SWIG_From_int(static_cast< int >(result));
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22315 PyObject *resultobj = 0;
22316 wxDateTime::Month arg1 ;
22317 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22318 wxString result;
22319 int val1 ;
22320 int ecode1 = 0 ;
22321 int val2 ;
22322 int ecode2 = 0 ;
22323 PyObject * obj0 = 0 ;
22324 PyObject * obj1 = 0 ;
22325 char * kwnames[] = {
22326 (char *) "month",(char *) "flags", NULL
22327 };
22328
22329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22330 ecode1 = SWIG_AsVal_int(obj0, &val1);
22331 if (!SWIG_IsOK(ecode1)) {
22332 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22333 }
22334 arg1 = static_cast< wxDateTime::Month >(val1);
22335 if (obj1) {
22336 ecode2 = SWIG_AsVal_int(obj1, &val2);
22337 if (!SWIG_IsOK(ecode2)) {
22338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22339 }
22340 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22341 }
22342 {
22343 PyThreadState* __tstate = wxPyBeginAllowThreads();
22344 result = wxDateTime::GetMonthName(arg1,arg2);
22345 wxPyEndAllowThreads(__tstate);
22346 if (PyErr_Occurred()) SWIG_fail;
22347 }
22348 {
22349 #if wxUSE_UNICODE
22350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22351 #else
22352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22353 #endif
22354 }
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22362 PyObject *resultobj = 0;
22363 wxDateTime::WeekDay arg1 ;
22364 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22365 wxString result;
22366 int val1 ;
22367 int ecode1 = 0 ;
22368 int val2 ;
22369 int ecode2 = 0 ;
22370 PyObject * obj0 = 0 ;
22371 PyObject * obj1 = 0 ;
22372 char * kwnames[] = {
22373 (char *) "weekday",(char *) "flags", NULL
22374 };
22375
22376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22377 ecode1 = SWIG_AsVal_int(obj0, &val1);
22378 if (!SWIG_IsOK(ecode1)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22380 }
22381 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22382 if (obj1) {
22383 ecode2 = SWIG_AsVal_int(obj1, &val2);
22384 if (!SWIG_IsOK(ecode2)) {
22385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22386 }
22387 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22388 }
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = wxDateTime::GetWeekDayName(arg1,arg2);
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 {
22396 #if wxUSE_UNICODE
22397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22398 #else
22399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22400 #endif
22401 }
22402 return resultobj;
22403 fail:
22404 return NULL;
22405 }
22406
22407
22408 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22409 PyObject *resultobj = 0;
22410 PyObject *result = 0 ;
22411
22412 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22413 {
22414 PyThreadState* __tstate = wxPyBeginAllowThreads();
22415 result = (PyObject *)wxDateTime_GetAmPmStrings();
22416 wxPyEndAllowThreads(__tstate);
22417 if (PyErr_Occurred()) SWIG_fail;
22418 }
22419 resultobj = result;
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22427 PyObject *resultobj = 0;
22428 int arg1 = (int) wxDateTime::Inv_Year ;
22429 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22430 bool result;
22431 int val1 ;
22432 int ecode1 = 0 ;
22433 int val2 ;
22434 int ecode2 = 0 ;
22435 PyObject * obj0 = 0 ;
22436 PyObject * obj1 = 0 ;
22437 char * kwnames[] = {
22438 (char *) "year",(char *) "country", NULL
22439 };
22440
22441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22442 if (obj0) {
22443 ecode1 = SWIG_AsVal_int(obj0, &val1);
22444 if (!SWIG_IsOK(ecode1)) {
22445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22446 }
22447 arg1 = static_cast< int >(val1);
22448 }
22449 if (obj1) {
22450 ecode2 = SWIG_AsVal_int(obj1, &val2);
22451 if (!SWIG_IsOK(ecode2)) {
22452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22453 }
22454 arg2 = static_cast< wxDateTime::Country >(val2);
22455 }
22456 {
22457 PyThreadState* __tstate = wxPyBeginAllowThreads();
22458 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 {
22463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22464 }
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22472 PyObject *resultobj = 0;
22473 int arg1 = (int) wxDateTime::Inv_Year ;
22474 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22475 wxDateTime result;
22476 int val1 ;
22477 int ecode1 = 0 ;
22478 int val2 ;
22479 int ecode2 = 0 ;
22480 PyObject * obj0 = 0 ;
22481 PyObject * obj1 = 0 ;
22482 char * kwnames[] = {
22483 (char *) "year",(char *) "country", NULL
22484 };
22485
22486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22487 if (obj0) {
22488 ecode1 = SWIG_AsVal_int(obj0, &val1);
22489 if (!SWIG_IsOK(ecode1)) {
22490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22491 }
22492 arg1 = static_cast< int >(val1);
22493 }
22494 if (obj1) {
22495 ecode2 = SWIG_AsVal_int(obj1, &val2);
22496 if (!SWIG_IsOK(ecode2)) {
22497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22498 }
22499 arg2 = static_cast< wxDateTime::Country >(val2);
22500 }
22501 {
22502 PyThreadState* __tstate = wxPyBeginAllowThreads();
22503 result = wxDateTime::GetBeginDST(arg1,arg2);
22504 wxPyEndAllowThreads(__tstate);
22505 if (PyErr_Occurred()) SWIG_fail;
22506 }
22507 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22508 return resultobj;
22509 fail:
22510 return NULL;
22511 }
22512
22513
22514 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22515 PyObject *resultobj = 0;
22516 int arg1 = (int) wxDateTime::Inv_Year ;
22517 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22518 wxDateTime result;
22519 int val1 ;
22520 int ecode1 = 0 ;
22521 int val2 ;
22522 int ecode2 = 0 ;
22523 PyObject * obj0 = 0 ;
22524 PyObject * obj1 = 0 ;
22525 char * kwnames[] = {
22526 (char *) "year",(char *) "country", NULL
22527 };
22528
22529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22530 if (obj0) {
22531 ecode1 = SWIG_AsVal_int(obj0, &val1);
22532 if (!SWIG_IsOK(ecode1)) {
22533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22534 }
22535 arg1 = static_cast< int >(val1);
22536 }
22537 if (obj1) {
22538 ecode2 = SWIG_AsVal_int(obj1, &val2);
22539 if (!SWIG_IsOK(ecode2)) {
22540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22541 }
22542 arg2 = static_cast< wxDateTime::Country >(val2);
22543 }
22544 {
22545 PyThreadState* __tstate = wxPyBeginAllowThreads();
22546 result = wxDateTime::GetEndDST(arg1,arg2);
22547 wxPyEndAllowThreads(__tstate);
22548 if (PyErr_Occurred()) SWIG_fail;
22549 }
22550 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22551 return resultobj;
22552 fail:
22553 return NULL;
22554 }
22555
22556
22557 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22558 PyObject *resultobj = 0;
22559 wxDateTime result;
22560
22561 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22562 {
22563 PyThreadState* __tstate = wxPyBeginAllowThreads();
22564 result = wxDateTime::Now();
22565 wxPyEndAllowThreads(__tstate);
22566 if (PyErr_Occurred()) SWIG_fail;
22567 }
22568 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22569 return resultobj;
22570 fail:
22571 return NULL;
22572 }
22573
22574
22575 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22576 PyObject *resultobj = 0;
22577 wxDateTime result;
22578
22579 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22580 {
22581 PyThreadState* __tstate = wxPyBeginAllowThreads();
22582 result = wxDateTime::UNow();
22583 wxPyEndAllowThreads(__tstate);
22584 if (PyErr_Occurred()) SWIG_fail;
22585 }
22586 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22587 return resultobj;
22588 fail:
22589 return NULL;
22590 }
22591
22592
22593 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22594 PyObject *resultobj = 0;
22595 wxDateTime result;
22596
22597 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22598 {
22599 PyThreadState* __tstate = wxPyBeginAllowThreads();
22600 result = wxDateTime::Today();
22601 wxPyEndAllowThreads(__tstate);
22602 if (PyErr_Occurred()) SWIG_fail;
22603 }
22604 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22605 return resultobj;
22606 fail:
22607 return NULL;
22608 }
22609
22610
22611 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22612 PyObject *resultobj = 0;
22613 wxDateTime *result = 0 ;
22614
22615 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22616 {
22617 PyThreadState* __tstate = wxPyBeginAllowThreads();
22618 result = (wxDateTime *)new wxDateTime();
22619 wxPyEndAllowThreads(__tstate);
22620 if (PyErr_Occurred()) SWIG_fail;
22621 }
22622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22623 return resultobj;
22624 fail:
22625 return NULL;
22626 }
22627
22628
22629 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22630 PyObject *resultobj = 0;
22631 time_t arg1 ;
22632 wxDateTime *result = 0 ;
22633 unsigned int val1 ;
22634 int ecode1 = 0 ;
22635 PyObject * obj0 = 0 ;
22636 char * kwnames[] = {
22637 (char *) "timet", NULL
22638 };
22639
22640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22641 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22642 if (!SWIG_IsOK(ecode1)) {
22643 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22644 }
22645 arg1 = static_cast< time_t >(val1);
22646 {
22647 PyThreadState* __tstate = wxPyBeginAllowThreads();
22648 result = (wxDateTime *)new wxDateTime(arg1);
22649 wxPyEndAllowThreads(__tstate);
22650 if (PyErr_Occurred()) SWIG_fail;
22651 }
22652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22653 return resultobj;
22654 fail:
22655 return NULL;
22656 }
22657
22658
22659 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22660 PyObject *resultobj = 0;
22661 double arg1 ;
22662 wxDateTime *result = 0 ;
22663 double val1 ;
22664 int ecode1 = 0 ;
22665 PyObject * obj0 = 0 ;
22666 char * kwnames[] = {
22667 (char *) "jdn", NULL
22668 };
22669
22670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22671 ecode1 = SWIG_AsVal_double(obj0, &val1);
22672 if (!SWIG_IsOK(ecode1)) {
22673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22674 }
22675 arg1 = static_cast< double >(val1);
22676 {
22677 PyThreadState* __tstate = wxPyBeginAllowThreads();
22678 result = (wxDateTime *)new wxDateTime(arg1);
22679 wxPyEndAllowThreads(__tstate);
22680 if (PyErr_Occurred()) SWIG_fail;
22681 }
22682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22690 PyObject *resultobj = 0;
22691 int arg1 ;
22692 int arg2 = (int) 0 ;
22693 int arg3 = (int) 0 ;
22694 int arg4 = (int) 0 ;
22695 wxDateTime *result = 0 ;
22696 int val1 ;
22697 int ecode1 = 0 ;
22698 int val2 ;
22699 int ecode2 = 0 ;
22700 int val3 ;
22701 int ecode3 = 0 ;
22702 int val4 ;
22703 int ecode4 = 0 ;
22704 PyObject * obj0 = 0 ;
22705 PyObject * obj1 = 0 ;
22706 PyObject * obj2 = 0 ;
22707 PyObject * obj3 = 0 ;
22708 char * kwnames[] = {
22709 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22710 };
22711
22712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22713 ecode1 = SWIG_AsVal_int(obj0, &val1);
22714 if (!SWIG_IsOK(ecode1)) {
22715 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22716 }
22717 arg1 = static_cast< int >(val1);
22718 if (obj1) {
22719 ecode2 = SWIG_AsVal_int(obj1, &val2);
22720 if (!SWIG_IsOK(ecode2)) {
22721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22722 }
22723 arg2 = static_cast< int >(val2);
22724 }
22725 if (obj2) {
22726 ecode3 = SWIG_AsVal_int(obj2, &val3);
22727 if (!SWIG_IsOK(ecode3)) {
22728 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22729 }
22730 arg3 = static_cast< int >(val3);
22731 }
22732 if (obj3) {
22733 ecode4 = SWIG_AsVal_int(obj3, &val4);
22734 if (!SWIG_IsOK(ecode4)) {
22735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22736 }
22737 arg4 = static_cast< int >(val4);
22738 }
22739 {
22740 PyThreadState* __tstate = wxPyBeginAllowThreads();
22741 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22742 wxPyEndAllowThreads(__tstate);
22743 if (PyErr_Occurred()) SWIG_fail;
22744 }
22745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22753 PyObject *resultobj = 0;
22754 int arg1 ;
22755 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22756 int arg3 = (int) wxDateTime::Inv_Year ;
22757 int arg4 = (int) 0 ;
22758 int arg5 = (int) 0 ;
22759 int arg6 = (int) 0 ;
22760 int arg7 = (int) 0 ;
22761 wxDateTime *result = 0 ;
22762 int val1 ;
22763 int ecode1 = 0 ;
22764 int val2 ;
22765 int ecode2 = 0 ;
22766 int val3 ;
22767 int ecode3 = 0 ;
22768 int val4 ;
22769 int ecode4 = 0 ;
22770 int val5 ;
22771 int ecode5 = 0 ;
22772 int val6 ;
22773 int ecode6 = 0 ;
22774 int val7 ;
22775 int ecode7 = 0 ;
22776 PyObject * obj0 = 0 ;
22777 PyObject * obj1 = 0 ;
22778 PyObject * obj2 = 0 ;
22779 PyObject * obj3 = 0 ;
22780 PyObject * obj4 = 0 ;
22781 PyObject * obj5 = 0 ;
22782 PyObject * obj6 = 0 ;
22783 char * kwnames[] = {
22784 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22785 };
22786
22787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22788 ecode1 = SWIG_AsVal_int(obj0, &val1);
22789 if (!SWIG_IsOK(ecode1)) {
22790 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22791 }
22792 arg1 = static_cast< int >(val1);
22793 if (obj1) {
22794 ecode2 = SWIG_AsVal_int(obj1, &val2);
22795 if (!SWIG_IsOK(ecode2)) {
22796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22797 }
22798 arg2 = static_cast< wxDateTime::Month >(val2);
22799 }
22800 if (obj2) {
22801 ecode3 = SWIG_AsVal_int(obj2, &val3);
22802 if (!SWIG_IsOK(ecode3)) {
22803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22804 }
22805 arg3 = static_cast< int >(val3);
22806 }
22807 if (obj3) {
22808 ecode4 = SWIG_AsVal_int(obj3, &val4);
22809 if (!SWIG_IsOK(ecode4)) {
22810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22811 }
22812 arg4 = static_cast< int >(val4);
22813 }
22814 if (obj4) {
22815 ecode5 = SWIG_AsVal_int(obj4, &val5);
22816 if (!SWIG_IsOK(ecode5)) {
22817 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22818 }
22819 arg5 = static_cast< int >(val5);
22820 }
22821 if (obj5) {
22822 ecode6 = SWIG_AsVal_int(obj5, &val6);
22823 if (!SWIG_IsOK(ecode6)) {
22824 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22825 }
22826 arg6 = static_cast< int >(val6);
22827 }
22828 if (obj6) {
22829 ecode7 = SWIG_AsVal_int(obj6, &val7);
22830 if (!SWIG_IsOK(ecode7)) {
22831 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22832 }
22833 arg7 = static_cast< int >(val7);
22834 }
22835 {
22836 PyThreadState* __tstate = wxPyBeginAllowThreads();
22837 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22838 wxPyEndAllowThreads(__tstate);
22839 if (PyErr_Occurred()) SWIG_fail;
22840 }
22841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22842 return resultobj;
22843 fail:
22844 return NULL;
22845 }
22846
22847
22848 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22849 PyObject *resultobj = 0;
22850 wxDateTime *arg1 = 0 ;
22851 wxDateTime *result = 0 ;
22852 void *argp1 = 0 ;
22853 int res1 = 0 ;
22854 PyObject * obj0 = 0 ;
22855 char * kwnames[] = {
22856 (char *) "date", NULL
22857 };
22858
22859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22860 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22861 if (!SWIG_IsOK(res1)) {
22862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22863 }
22864 if (!argp1) {
22865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22866 }
22867 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22868 {
22869 PyThreadState* __tstate = wxPyBeginAllowThreads();
22870 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22871 wxPyEndAllowThreads(__tstate);
22872 if (PyErr_Occurred()) SWIG_fail;
22873 }
22874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22875 return resultobj;
22876 fail:
22877 return NULL;
22878 }
22879
22880
22881 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22882 PyObject *resultobj = 0;
22883 wxDateTime *arg1 = (wxDateTime *) 0 ;
22884 void *argp1 = 0 ;
22885 int res1 = 0 ;
22886 PyObject *swig_obj[1] ;
22887
22888 if (!args) SWIG_fail;
22889 swig_obj[0] = args;
22890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22891 if (!SWIG_IsOK(res1)) {
22892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22893 }
22894 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22895 {
22896 PyThreadState* __tstate = wxPyBeginAllowThreads();
22897 delete arg1;
22898
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 resultobj = SWIG_Py_Void();
22903 return resultobj;
22904 fail:
22905 return NULL;
22906 }
22907
22908
22909 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22910 PyObject *resultobj = 0;
22911 wxDateTime *arg1 = (wxDateTime *) 0 ;
22912 wxDateTime *result = 0 ;
22913 void *argp1 = 0 ;
22914 int res1 = 0 ;
22915 PyObject *swig_obj[1] ;
22916
22917 if (!args) SWIG_fail;
22918 swig_obj[0] = args;
22919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22920 if (!SWIG_IsOK(res1)) {
22921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22922 }
22923 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22924 {
22925 PyThreadState* __tstate = wxPyBeginAllowThreads();
22926 {
22927 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22928 result = (wxDateTime *) &_result_ref;
22929 }
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22934 return resultobj;
22935 fail:
22936 return NULL;
22937 }
22938
22939
22940 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22941 PyObject *resultobj = 0;
22942 wxDateTime *arg1 = (wxDateTime *) 0 ;
22943 time_t arg2 ;
22944 wxDateTime *result = 0 ;
22945 void *argp1 = 0 ;
22946 int res1 = 0 ;
22947 unsigned int val2 ;
22948 int ecode2 = 0 ;
22949 PyObject * obj0 = 0 ;
22950 PyObject * obj1 = 0 ;
22951 char * kwnames[] = {
22952 (char *) "self",(char *) "timet", NULL
22953 };
22954
22955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22957 if (!SWIG_IsOK(res1)) {
22958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22959 }
22960 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22961 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22962 if (!SWIG_IsOK(ecode2)) {
22963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22964 }
22965 arg2 = static_cast< time_t >(val2);
22966 {
22967 PyThreadState* __tstate = wxPyBeginAllowThreads();
22968 {
22969 wxDateTime &_result_ref = (arg1)->Set(arg2);
22970 result = (wxDateTime *) &_result_ref;
22971 }
22972 wxPyEndAllowThreads(__tstate);
22973 if (PyErr_Occurred()) SWIG_fail;
22974 }
22975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22976 return resultobj;
22977 fail:
22978 return NULL;
22979 }
22980
22981
22982 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22983 PyObject *resultobj = 0;
22984 wxDateTime *arg1 = (wxDateTime *) 0 ;
22985 double arg2 ;
22986 wxDateTime *result = 0 ;
22987 void *argp1 = 0 ;
22988 int res1 = 0 ;
22989 double val2 ;
22990 int ecode2 = 0 ;
22991 PyObject * obj0 = 0 ;
22992 PyObject * obj1 = 0 ;
22993 char * kwnames[] = {
22994 (char *) "self",(char *) "jdn", NULL
22995 };
22996
22997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22999 if (!SWIG_IsOK(res1)) {
23000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23001 }
23002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23003 ecode2 = SWIG_AsVal_double(obj1, &val2);
23004 if (!SWIG_IsOK(ecode2)) {
23005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23006 }
23007 arg2 = static_cast< double >(val2);
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 {
23011 wxDateTime &_result_ref = (arg1)->Set(arg2);
23012 result = (wxDateTime *) &_result_ref;
23013 }
23014 wxPyEndAllowThreads(__tstate);
23015 if (PyErr_Occurred()) SWIG_fail;
23016 }
23017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23018 return resultobj;
23019 fail:
23020 return NULL;
23021 }
23022
23023
23024 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23025 PyObject *resultobj = 0;
23026 wxDateTime *arg1 = (wxDateTime *) 0 ;
23027 int arg2 ;
23028 int arg3 = (int) 0 ;
23029 int arg4 = (int) 0 ;
23030 int arg5 = (int) 0 ;
23031 wxDateTime *result = 0 ;
23032 void *argp1 = 0 ;
23033 int res1 = 0 ;
23034 int val2 ;
23035 int ecode2 = 0 ;
23036 int val3 ;
23037 int ecode3 = 0 ;
23038 int val4 ;
23039 int ecode4 = 0 ;
23040 int val5 ;
23041 int ecode5 = 0 ;
23042 PyObject * obj0 = 0 ;
23043 PyObject * obj1 = 0 ;
23044 PyObject * obj2 = 0 ;
23045 PyObject * obj3 = 0 ;
23046 PyObject * obj4 = 0 ;
23047 char * kwnames[] = {
23048 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23049 };
23050
23051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23053 if (!SWIG_IsOK(res1)) {
23054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
23055 }
23056 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23057 ecode2 = SWIG_AsVal_int(obj1, &val2);
23058 if (!SWIG_IsOK(ecode2)) {
23059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
23060 }
23061 arg2 = static_cast< int >(val2);
23062 if (obj2) {
23063 ecode3 = SWIG_AsVal_int(obj2, &val3);
23064 if (!SWIG_IsOK(ecode3)) {
23065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
23066 }
23067 arg3 = static_cast< int >(val3);
23068 }
23069 if (obj3) {
23070 ecode4 = SWIG_AsVal_int(obj3, &val4);
23071 if (!SWIG_IsOK(ecode4)) {
23072 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
23073 }
23074 arg4 = static_cast< int >(val4);
23075 }
23076 if (obj4) {
23077 ecode5 = SWIG_AsVal_int(obj4, &val5);
23078 if (!SWIG_IsOK(ecode5)) {
23079 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
23080 }
23081 arg5 = static_cast< int >(val5);
23082 }
23083 {
23084 PyThreadState* __tstate = wxPyBeginAllowThreads();
23085 {
23086 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
23087 result = (wxDateTime *) &_result_ref;
23088 }
23089 wxPyEndAllowThreads(__tstate);
23090 if (PyErr_Occurred()) SWIG_fail;
23091 }
23092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23093 return resultobj;
23094 fail:
23095 return NULL;
23096 }
23097
23098
23099 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23100 PyObject *resultobj = 0;
23101 wxDateTime *arg1 = (wxDateTime *) 0 ;
23102 int arg2 ;
23103 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23104 int arg4 = (int) wxDateTime::Inv_Year ;
23105 int arg5 = (int) 0 ;
23106 int arg6 = (int) 0 ;
23107 int arg7 = (int) 0 ;
23108 int arg8 = (int) 0 ;
23109 wxDateTime *result = 0 ;
23110 void *argp1 = 0 ;
23111 int res1 = 0 ;
23112 int val2 ;
23113 int ecode2 = 0 ;
23114 int val3 ;
23115 int ecode3 = 0 ;
23116 int val4 ;
23117 int ecode4 = 0 ;
23118 int val5 ;
23119 int ecode5 = 0 ;
23120 int val6 ;
23121 int ecode6 = 0 ;
23122 int val7 ;
23123 int ecode7 = 0 ;
23124 int val8 ;
23125 int ecode8 = 0 ;
23126 PyObject * obj0 = 0 ;
23127 PyObject * obj1 = 0 ;
23128 PyObject * obj2 = 0 ;
23129 PyObject * obj3 = 0 ;
23130 PyObject * obj4 = 0 ;
23131 PyObject * obj5 = 0 ;
23132 PyObject * obj6 = 0 ;
23133 PyObject * obj7 = 0 ;
23134 char * kwnames[] = {
23135 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23136 };
23137
23138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23140 if (!SWIG_IsOK(res1)) {
23141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23142 }
23143 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23144 ecode2 = SWIG_AsVal_int(obj1, &val2);
23145 if (!SWIG_IsOK(ecode2)) {
23146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23147 }
23148 arg2 = static_cast< int >(val2);
23149 if (obj2) {
23150 ecode3 = SWIG_AsVal_int(obj2, &val3);
23151 if (!SWIG_IsOK(ecode3)) {
23152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23153 }
23154 arg3 = static_cast< wxDateTime::Month >(val3);
23155 }
23156 if (obj3) {
23157 ecode4 = SWIG_AsVal_int(obj3, &val4);
23158 if (!SWIG_IsOK(ecode4)) {
23159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23160 }
23161 arg4 = static_cast< int >(val4);
23162 }
23163 if (obj4) {
23164 ecode5 = SWIG_AsVal_int(obj4, &val5);
23165 if (!SWIG_IsOK(ecode5)) {
23166 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23167 }
23168 arg5 = static_cast< int >(val5);
23169 }
23170 if (obj5) {
23171 ecode6 = SWIG_AsVal_int(obj5, &val6);
23172 if (!SWIG_IsOK(ecode6)) {
23173 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23174 }
23175 arg6 = static_cast< int >(val6);
23176 }
23177 if (obj6) {
23178 ecode7 = SWIG_AsVal_int(obj6, &val7);
23179 if (!SWIG_IsOK(ecode7)) {
23180 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23181 }
23182 arg7 = static_cast< int >(val7);
23183 }
23184 if (obj7) {
23185 ecode8 = SWIG_AsVal_int(obj7, &val8);
23186 if (!SWIG_IsOK(ecode8)) {
23187 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23188 }
23189 arg8 = static_cast< int >(val8);
23190 }
23191 {
23192 PyThreadState* __tstate = wxPyBeginAllowThreads();
23193 {
23194 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23195 result = (wxDateTime *) &_result_ref;
23196 }
23197 wxPyEndAllowThreads(__tstate);
23198 if (PyErr_Occurred()) SWIG_fail;
23199 }
23200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23201 return resultobj;
23202 fail:
23203 return NULL;
23204 }
23205
23206
23207 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23208 PyObject *resultobj = 0;
23209 wxDateTime *arg1 = (wxDateTime *) 0 ;
23210 wxDateTime *result = 0 ;
23211 void *argp1 = 0 ;
23212 int res1 = 0 ;
23213 PyObject *swig_obj[1] ;
23214
23215 if (!args) SWIG_fail;
23216 swig_obj[0] = args;
23217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23218 if (!SWIG_IsOK(res1)) {
23219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23220 }
23221 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23222 {
23223 PyThreadState* __tstate = wxPyBeginAllowThreads();
23224 {
23225 wxDateTime &_result_ref = (arg1)->ResetTime();
23226 result = (wxDateTime *) &_result_ref;
23227 }
23228 wxPyEndAllowThreads(__tstate);
23229 if (PyErr_Occurred()) SWIG_fail;
23230 }
23231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23232 return resultobj;
23233 fail:
23234 return NULL;
23235 }
23236
23237
23238 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23239 PyObject *resultobj = 0;
23240 wxDateTime *arg1 = (wxDateTime *) 0 ;
23241 int arg2 ;
23242 wxDateTime *result = 0 ;
23243 void *argp1 = 0 ;
23244 int res1 = 0 ;
23245 int val2 ;
23246 int ecode2 = 0 ;
23247 PyObject * obj0 = 0 ;
23248 PyObject * obj1 = 0 ;
23249 char * kwnames[] = {
23250 (char *) "self",(char *) "year", NULL
23251 };
23252
23253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23255 if (!SWIG_IsOK(res1)) {
23256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23257 }
23258 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23259 ecode2 = SWIG_AsVal_int(obj1, &val2);
23260 if (!SWIG_IsOK(ecode2)) {
23261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23262 }
23263 arg2 = static_cast< int >(val2);
23264 {
23265 PyThreadState* __tstate = wxPyBeginAllowThreads();
23266 {
23267 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23268 result = (wxDateTime *) &_result_ref;
23269 }
23270 wxPyEndAllowThreads(__tstate);
23271 if (PyErr_Occurred()) SWIG_fail;
23272 }
23273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23274 return resultobj;
23275 fail:
23276 return NULL;
23277 }
23278
23279
23280 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23281 PyObject *resultobj = 0;
23282 wxDateTime *arg1 = (wxDateTime *) 0 ;
23283 wxDateTime::Month arg2 ;
23284 wxDateTime *result = 0 ;
23285 void *argp1 = 0 ;
23286 int res1 = 0 ;
23287 int val2 ;
23288 int ecode2 = 0 ;
23289 PyObject * obj0 = 0 ;
23290 PyObject * obj1 = 0 ;
23291 char * kwnames[] = {
23292 (char *) "self",(char *) "month", NULL
23293 };
23294
23295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23297 if (!SWIG_IsOK(res1)) {
23298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23299 }
23300 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23301 ecode2 = SWIG_AsVal_int(obj1, &val2);
23302 if (!SWIG_IsOK(ecode2)) {
23303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23304 }
23305 arg2 = static_cast< wxDateTime::Month >(val2);
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 {
23309 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23310 result = (wxDateTime *) &_result_ref;
23311 }
23312 wxPyEndAllowThreads(__tstate);
23313 if (PyErr_Occurred()) SWIG_fail;
23314 }
23315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23316 return resultobj;
23317 fail:
23318 return NULL;
23319 }
23320
23321
23322 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23323 PyObject *resultobj = 0;
23324 wxDateTime *arg1 = (wxDateTime *) 0 ;
23325 int arg2 ;
23326 wxDateTime *result = 0 ;
23327 void *argp1 = 0 ;
23328 int res1 = 0 ;
23329 int val2 ;
23330 int ecode2 = 0 ;
23331 PyObject * obj0 = 0 ;
23332 PyObject * obj1 = 0 ;
23333 char * kwnames[] = {
23334 (char *) "self",(char *) "day", NULL
23335 };
23336
23337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23339 if (!SWIG_IsOK(res1)) {
23340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23341 }
23342 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23343 ecode2 = SWIG_AsVal_int(obj1, &val2);
23344 if (!SWIG_IsOK(ecode2)) {
23345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23346 }
23347 arg2 = static_cast< int >(val2);
23348 {
23349 PyThreadState* __tstate = wxPyBeginAllowThreads();
23350 {
23351 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23352 result = (wxDateTime *) &_result_ref;
23353 }
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23358 return resultobj;
23359 fail:
23360 return NULL;
23361 }
23362
23363
23364 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23365 PyObject *resultobj = 0;
23366 wxDateTime *arg1 = (wxDateTime *) 0 ;
23367 int arg2 ;
23368 wxDateTime *result = 0 ;
23369 void *argp1 = 0 ;
23370 int res1 = 0 ;
23371 int val2 ;
23372 int ecode2 = 0 ;
23373 PyObject * obj0 = 0 ;
23374 PyObject * obj1 = 0 ;
23375 char * kwnames[] = {
23376 (char *) "self",(char *) "hour", NULL
23377 };
23378
23379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23381 if (!SWIG_IsOK(res1)) {
23382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23383 }
23384 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23385 ecode2 = SWIG_AsVal_int(obj1, &val2);
23386 if (!SWIG_IsOK(ecode2)) {
23387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23388 }
23389 arg2 = static_cast< int >(val2);
23390 {
23391 PyThreadState* __tstate = wxPyBeginAllowThreads();
23392 {
23393 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23394 result = (wxDateTime *) &_result_ref;
23395 }
23396 wxPyEndAllowThreads(__tstate);
23397 if (PyErr_Occurred()) SWIG_fail;
23398 }
23399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj = 0;
23408 wxDateTime *arg1 = (wxDateTime *) 0 ;
23409 int arg2 ;
23410 wxDateTime *result = 0 ;
23411 void *argp1 = 0 ;
23412 int res1 = 0 ;
23413 int val2 ;
23414 int ecode2 = 0 ;
23415 PyObject * obj0 = 0 ;
23416 PyObject * obj1 = 0 ;
23417 char * kwnames[] = {
23418 (char *) "self",(char *) "minute", NULL
23419 };
23420
23421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23423 if (!SWIG_IsOK(res1)) {
23424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23425 }
23426 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23427 ecode2 = SWIG_AsVal_int(obj1, &val2);
23428 if (!SWIG_IsOK(ecode2)) {
23429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23430 }
23431 arg2 = static_cast< int >(val2);
23432 {
23433 PyThreadState* __tstate = wxPyBeginAllowThreads();
23434 {
23435 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23436 result = (wxDateTime *) &_result_ref;
23437 }
23438 wxPyEndAllowThreads(__tstate);
23439 if (PyErr_Occurred()) SWIG_fail;
23440 }
23441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23442 return resultobj;
23443 fail:
23444 return NULL;
23445 }
23446
23447
23448 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23449 PyObject *resultobj = 0;
23450 wxDateTime *arg1 = (wxDateTime *) 0 ;
23451 int arg2 ;
23452 wxDateTime *result = 0 ;
23453 void *argp1 = 0 ;
23454 int res1 = 0 ;
23455 int val2 ;
23456 int ecode2 = 0 ;
23457 PyObject * obj0 = 0 ;
23458 PyObject * obj1 = 0 ;
23459 char * kwnames[] = {
23460 (char *) "self",(char *) "second", NULL
23461 };
23462
23463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23465 if (!SWIG_IsOK(res1)) {
23466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23467 }
23468 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23469 ecode2 = SWIG_AsVal_int(obj1, &val2);
23470 if (!SWIG_IsOK(ecode2)) {
23471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23472 }
23473 arg2 = static_cast< int >(val2);
23474 {
23475 PyThreadState* __tstate = wxPyBeginAllowThreads();
23476 {
23477 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23478 result = (wxDateTime *) &_result_ref;
23479 }
23480 wxPyEndAllowThreads(__tstate);
23481 if (PyErr_Occurred()) SWIG_fail;
23482 }
23483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23484 return resultobj;
23485 fail:
23486 return NULL;
23487 }
23488
23489
23490 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23491 PyObject *resultobj = 0;
23492 wxDateTime *arg1 = (wxDateTime *) 0 ;
23493 int arg2 ;
23494 wxDateTime *result = 0 ;
23495 void *argp1 = 0 ;
23496 int res1 = 0 ;
23497 int val2 ;
23498 int ecode2 = 0 ;
23499 PyObject * obj0 = 0 ;
23500 PyObject * obj1 = 0 ;
23501 char * kwnames[] = {
23502 (char *) "self",(char *) "millisecond", NULL
23503 };
23504
23505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23507 if (!SWIG_IsOK(res1)) {
23508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23509 }
23510 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23511 ecode2 = SWIG_AsVal_int(obj1, &val2);
23512 if (!SWIG_IsOK(ecode2)) {
23513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23514 }
23515 arg2 = static_cast< int >(val2);
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 {
23519 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23520 result = (wxDateTime *) &_result_ref;
23521 }
23522 wxPyEndAllowThreads(__tstate);
23523 if (PyErr_Occurred()) SWIG_fail;
23524 }
23525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23526 return resultobj;
23527 fail:
23528 return NULL;
23529 }
23530
23531
23532 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23533 PyObject *resultobj = 0;
23534 wxDateTime *arg1 = (wxDateTime *) 0 ;
23535 wxDateTime::WeekDay arg2 ;
23536 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23537 wxDateTime *result = 0 ;
23538 void *argp1 = 0 ;
23539 int res1 = 0 ;
23540 int val2 ;
23541 int ecode2 = 0 ;
23542 int val3 ;
23543 int ecode3 = 0 ;
23544 PyObject * obj0 = 0 ;
23545 PyObject * obj1 = 0 ;
23546 PyObject * obj2 = 0 ;
23547 char * kwnames[] = {
23548 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23549 };
23550
23551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23553 if (!SWIG_IsOK(res1)) {
23554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23555 }
23556 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23557 ecode2 = SWIG_AsVal_int(obj1, &val2);
23558 if (!SWIG_IsOK(ecode2)) {
23559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23560 }
23561 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23562 if (obj2) {
23563 ecode3 = SWIG_AsVal_int(obj2, &val3);
23564 if (!SWIG_IsOK(ecode3)) {
23565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23566 }
23567 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23568 }
23569 {
23570 PyThreadState* __tstate = wxPyBeginAllowThreads();
23571 {
23572 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23573 result = (wxDateTime *) &_result_ref;
23574 }
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23579 return resultobj;
23580 fail:
23581 return NULL;
23582 }
23583
23584
23585 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23586 PyObject *resultobj = 0;
23587 wxDateTime *arg1 = (wxDateTime *) 0 ;
23588 wxDateTime::WeekDay arg2 ;
23589 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23590 wxDateTime result;
23591 void *argp1 = 0 ;
23592 int res1 = 0 ;
23593 int val2 ;
23594 int ecode2 = 0 ;
23595 int val3 ;
23596 int ecode3 = 0 ;
23597 PyObject * obj0 = 0 ;
23598 PyObject * obj1 = 0 ;
23599 PyObject * obj2 = 0 ;
23600 char * kwnames[] = {
23601 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23602 };
23603
23604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23606 if (!SWIG_IsOK(res1)) {
23607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23608 }
23609 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23610 ecode2 = SWIG_AsVal_int(obj1, &val2);
23611 if (!SWIG_IsOK(ecode2)) {
23612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23613 }
23614 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23615 if (obj2) {
23616 ecode3 = SWIG_AsVal_int(obj2, &val3);
23617 if (!SWIG_IsOK(ecode3)) {
23618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23619 }
23620 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23621 }
23622 {
23623 PyThreadState* __tstate = wxPyBeginAllowThreads();
23624 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23625 wxPyEndAllowThreads(__tstate);
23626 if (PyErr_Occurred()) SWIG_fail;
23627 }
23628 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23629 return resultobj;
23630 fail:
23631 return NULL;
23632 }
23633
23634
23635 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23636 PyObject *resultobj = 0;
23637 wxDateTime *arg1 = (wxDateTime *) 0 ;
23638 wxDateTime::WeekDay arg2 ;
23639 wxDateTime *result = 0 ;
23640 void *argp1 = 0 ;
23641 int res1 = 0 ;
23642 int val2 ;
23643 int ecode2 = 0 ;
23644 PyObject * obj0 = 0 ;
23645 PyObject * obj1 = 0 ;
23646 char * kwnames[] = {
23647 (char *) "self",(char *) "weekday", NULL
23648 };
23649
23650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23652 if (!SWIG_IsOK(res1)) {
23653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23654 }
23655 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23656 ecode2 = SWIG_AsVal_int(obj1, &val2);
23657 if (!SWIG_IsOK(ecode2)) {
23658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23659 }
23660 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23661 {
23662 PyThreadState* __tstate = wxPyBeginAllowThreads();
23663 {
23664 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23665 result = (wxDateTime *) &_result_ref;
23666 }
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj = 0;
23679 wxDateTime *arg1 = (wxDateTime *) 0 ;
23680 wxDateTime::WeekDay arg2 ;
23681 wxDateTime result;
23682 void *argp1 = 0 ;
23683 int res1 = 0 ;
23684 int val2 ;
23685 int ecode2 = 0 ;
23686 PyObject * obj0 = 0 ;
23687 PyObject * obj1 = 0 ;
23688 char * kwnames[] = {
23689 (char *) "self",(char *) "weekday", NULL
23690 };
23691
23692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23694 if (!SWIG_IsOK(res1)) {
23695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23696 }
23697 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23698 ecode2 = SWIG_AsVal_int(obj1, &val2);
23699 if (!SWIG_IsOK(ecode2)) {
23700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23701 }
23702 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23703 {
23704 PyThreadState* __tstate = wxPyBeginAllowThreads();
23705 result = (arg1)->GetNextWeekDay(arg2);
23706 wxPyEndAllowThreads(__tstate);
23707 if (PyErr_Occurred()) SWIG_fail;
23708 }
23709 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23710 return resultobj;
23711 fail:
23712 return NULL;
23713 }
23714
23715
23716 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23717 PyObject *resultobj = 0;
23718 wxDateTime *arg1 = (wxDateTime *) 0 ;
23719 wxDateTime::WeekDay arg2 ;
23720 wxDateTime *result = 0 ;
23721 void *argp1 = 0 ;
23722 int res1 = 0 ;
23723 int val2 ;
23724 int ecode2 = 0 ;
23725 PyObject * obj0 = 0 ;
23726 PyObject * obj1 = 0 ;
23727 char * kwnames[] = {
23728 (char *) "self",(char *) "weekday", NULL
23729 };
23730
23731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23733 if (!SWIG_IsOK(res1)) {
23734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23735 }
23736 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23737 ecode2 = SWIG_AsVal_int(obj1, &val2);
23738 if (!SWIG_IsOK(ecode2)) {
23739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23740 }
23741 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23742 {
23743 PyThreadState* __tstate = wxPyBeginAllowThreads();
23744 {
23745 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23746 result = (wxDateTime *) &_result_ref;
23747 }
23748 wxPyEndAllowThreads(__tstate);
23749 if (PyErr_Occurred()) SWIG_fail;
23750 }
23751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23752 return resultobj;
23753 fail:
23754 return NULL;
23755 }
23756
23757
23758 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23759 PyObject *resultobj = 0;
23760 wxDateTime *arg1 = (wxDateTime *) 0 ;
23761 wxDateTime::WeekDay arg2 ;
23762 wxDateTime result;
23763 void *argp1 = 0 ;
23764 int res1 = 0 ;
23765 int val2 ;
23766 int ecode2 = 0 ;
23767 PyObject * obj0 = 0 ;
23768 PyObject * obj1 = 0 ;
23769 char * kwnames[] = {
23770 (char *) "self",(char *) "weekday", NULL
23771 };
23772
23773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23775 if (!SWIG_IsOK(res1)) {
23776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23777 }
23778 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23779 ecode2 = SWIG_AsVal_int(obj1, &val2);
23780 if (!SWIG_IsOK(ecode2)) {
23781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23782 }
23783 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23784 {
23785 PyThreadState* __tstate = wxPyBeginAllowThreads();
23786 result = (arg1)->GetPrevWeekDay(arg2);
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj = 0;
23799 wxDateTime *arg1 = (wxDateTime *) 0 ;
23800 wxDateTime::WeekDay arg2 ;
23801 int arg3 = (int) 1 ;
23802 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23803 int arg5 = (int) wxDateTime::Inv_Year ;
23804 bool result;
23805 void *argp1 = 0 ;
23806 int res1 = 0 ;
23807 int val2 ;
23808 int ecode2 = 0 ;
23809 int val3 ;
23810 int ecode3 = 0 ;
23811 int val4 ;
23812 int ecode4 = 0 ;
23813 int val5 ;
23814 int ecode5 = 0 ;
23815 PyObject * obj0 = 0 ;
23816 PyObject * obj1 = 0 ;
23817 PyObject * obj2 = 0 ;
23818 PyObject * obj3 = 0 ;
23819 PyObject * obj4 = 0 ;
23820 char * kwnames[] = {
23821 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23822 };
23823
23824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23826 if (!SWIG_IsOK(res1)) {
23827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23828 }
23829 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23830 ecode2 = SWIG_AsVal_int(obj1, &val2);
23831 if (!SWIG_IsOK(ecode2)) {
23832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23833 }
23834 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23835 if (obj2) {
23836 ecode3 = SWIG_AsVal_int(obj2, &val3);
23837 if (!SWIG_IsOK(ecode3)) {
23838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23839 }
23840 arg3 = static_cast< int >(val3);
23841 }
23842 if (obj3) {
23843 ecode4 = SWIG_AsVal_int(obj3, &val4);
23844 if (!SWIG_IsOK(ecode4)) {
23845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23846 }
23847 arg4 = static_cast< wxDateTime::Month >(val4);
23848 }
23849 if (obj4) {
23850 ecode5 = SWIG_AsVal_int(obj4, &val5);
23851 if (!SWIG_IsOK(ecode5)) {
23852 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23853 }
23854 arg5 = static_cast< int >(val5);
23855 }
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23859 wxPyEndAllowThreads(__tstate);
23860 if (PyErr_Occurred()) SWIG_fail;
23861 }
23862 {
23863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23864 }
23865 return resultobj;
23866 fail:
23867 return NULL;
23868 }
23869
23870
23871 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23872 PyObject *resultobj = 0;
23873 wxDateTime *arg1 = (wxDateTime *) 0 ;
23874 wxDateTime::WeekDay arg2 ;
23875 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23876 int arg4 = (int) wxDateTime::Inv_Year ;
23877 bool result;
23878 void *argp1 = 0 ;
23879 int res1 = 0 ;
23880 int val2 ;
23881 int ecode2 = 0 ;
23882 int val3 ;
23883 int ecode3 = 0 ;
23884 int val4 ;
23885 int ecode4 = 0 ;
23886 PyObject * obj0 = 0 ;
23887 PyObject * obj1 = 0 ;
23888 PyObject * obj2 = 0 ;
23889 PyObject * obj3 = 0 ;
23890 char * kwnames[] = {
23891 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23892 };
23893
23894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23896 if (!SWIG_IsOK(res1)) {
23897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23898 }
23899 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23900 ecode2 = SWIG_AsVal_int(obj1, &val2);
23901 if (!SWIG_IsOK(ecode2)) {
23902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23903 }
23904 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23905 if (obj2) {
23906 ecode3 = SWIG_AsVal_int(obj2, &val3);
23907 if (!SWIG_IsOK(ecode3)) {
23908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23909 }
23910 arg3 = static_cast< wxDateTime::Month >(val3);
23911 }
23912 if (obj3) {
23913 ecode4 = SWIG_AsVal_int(obj3, &val4);
23914 if (!SWIG_IsOK(ecode4)) {
23915 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23916 }
23917 arg4 = static_cast< int >(val4);
23918 }
23919 {
23920 PyThreadState* __tstate = wxPyBeginAllowThreads();
23921 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23922 wxPyEndAllowThreads(__tstate);
23923 if (PyErr_Occurred()) SWIG_fail;
23924 }
23925 {
23926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23927 }
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23935 PyObject *resultobj = 0;
23936 wxDateTime *arg1 = (wxDateTime *) 0 ;
23937 wxDateTime::WeekDay arg2 ;
23938 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23939 int arg4 = (int) wxDateTime::Inv_Year ;
23940 wxDateTime result;
23941 void *argp1 = 0 ;
23942 int res1 = 0 ;
23943 int val2 ;
23944 int ecode2 = 0 ;
23945 int val3 ;
23946 int ecode3 = 0 ;
23947 int val4 ;
23948 int ecode4 = 0 ;
23949 PyObject * obj0 = 0 ;
23950 PyObject * obj1 = 0 ;
23951 PyObject * obj2 = 0 ;
23952 PyObject * obj3 = 0 ;
23953 char * kwnames[] = {
23954 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23955 };
23956
23957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23959 if (!SWIG_IsOK(res1)) {
23960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23961 }
23962 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23963 ecode2 = SWIG_AsVal_int(obj1, &val2);
23964 if (!SWIG_IsOK(ecode2)) {
23965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23966 }
23967 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23968 if (obj2) {
23969 ecode3 = SWIG_AsVal_int(obj2, &val3);
23970 if (!SWIG_IsOK(ecode3)) {
23971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23972 }
23973 arg3 = static_cast< wxDateTime::Month >(val3);
23974 }
23975 if (obj3) {
23976 ecode4 = SWIG_AsVal_int(obj3, &val4);
23977 if (!SWIG_IsOK(ecode4)) {
23978 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23979 }
23980 arg4 = static_cast< int >(val4);
23981 }
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23989 return resultobj;
23990 fail:
23991 return NULL;
23992 }
23993
23994
23995 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23996 PyObject *resultobj = 0;
23997 wxDateTime *arg1 = (wxDateTime *) 0 ;
23998 int arg2 ;
23999 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24000 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24001 bool result;
24002 void *argp1 = 0 ;
24003 int res1 = 0 ;
24004 int val2 ;
24005 int ecode2 = 0 ;
24006 int val3 ;
24007 int ecode3 = 0 ;
24008 int val4 ;
24009 int ecode4 = 0 ;
24010 PyObject * obj0 = 0 ;
24011 PyObject * obj1 = 0 ;
24012 PyObject * obj2 = 0 ;
24013 PyObject * obj3 = 0 ;
24014 char * kwnames[] = {
24015 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24016 };
24017
24018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24020 if (!SWIG_IsOK(res1)) {
24021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24022 }
24023 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24024 ecode2 = SWIG_AsVal_int(obj1, &val2);
24025 if (!SWIG_IsOK(ecode2)) {
24026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24027 }
24028 arg2 = static_cast< int >(val2);
24029 if (obj2) {
24030 ecode3 = SWIG_AsVal_int(obj2, &val3);
24031 if (!SWIG_IsOK(ecode3)) {
24032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24033 }
24034 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24035 }
24036 if (obj3) {
24037 ecode4 = SWIG_AsVal_int(obj3, &val4);
24038 if (!SWIG_IsOK(ecode4)) {
24039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24040 }
24041 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24042 }
24043 {
24044 PyThreadState* __tstate = wxPyBeginAllowThreads();
24045 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24046 wxPyEndAllowThreads(__tstate);
24047 if (PyErr_Occurred()) SWIG_fail;
24048 }
24049 {
24050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24051 }
24052 return resultobj;
24053 fail:
24054 return NULL;
24055 }
24056
24057
24058 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24059 PyObject *resultobj = 0;
24060 wxDateTime *arg1 = (wxDateTime *) 0 ;
24061 int arg2 ;
24062 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24063 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24064 wxDateTime result;
24065 void *argp1 = 0 ;
24066 int res1 = 0 ;
24067 int val2 ;
24068 int ecode2 = 0 ;
24069 int val3 ;
24070 int ecode3 = 0 ;
24071 int val4 ;
24072 int ecode4 = 0 ;
24073 PyObject * obj0 = 0 ;
24074 PyObject * obj1 = 0 ;
24075 PyObject * obj2 = 0 ;
24076 PyObject * obj3 = 0 ;
24077 char * kwnames[] = {
24078 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24079 };
24080
24081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24083 if (!SWIG_IsOK(res1)) {
24084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24085 }
24086 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24087 ecode2 = SWIG_AsVal_int(obj1, &val2);
24088 if (!SWIG_IsOK(ecode2)) {
24089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
24090 }
24091 arg2 = static_cast< int >(val2);
24092 if (obj2) {
24093 ecode3 = SWIG_AsVal_int(obj2, &val3);
24094 if (!SWIG_IsOK(ecode3)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24096 }
24097 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24098 }
24099 if (obj3) {
24100 ecode4 = SWIG_AsVal_int(obj3, &val4);
24101 if (!SWIG_IsOK(ecode4)) {
24102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24103 }
24104 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24105 }
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = (arg1)->GetWeek(arg2,arg3,arg4);
24109 wxPyEndAllowThreads(__tstate);
24110 if (PyErr_Occurred()) SWIG_fail;
24111 }
24112 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24120 PyObject *resultobj = 0;
24121 int arg1 ;
24122 int arg2 ;
24123 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24124 wxDateTime result;
24125 int val1 ;
24126 int ecode1 = 0 ;
24127 int val2 ;
24128 int ecode2 = 0 ;
24129 int val3 ;
24130 int ecode3 = 0 ;
24131 PyObject * obj0 = 0 ;
24132 PyObject * obj1 = 0 ;
24133 PyObject * obj2 = 0 ;
24134 char * kwnames[] = {
24135 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24136 };
24137
24138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24139 ecode1 = SWIG_AsVal_int(obj0, &val1);
24140 if (!SWIG_IsOK(ecode1)) {
24141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24142 }
24143 arg1 = static_cast< int >(val1);
24144 ecode2 = SWIG_AsVal_int(obj1, &val2);
24145 if (!SWIG_IsOK(ecode2)) {
24146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24147 }
24148 arg2 = static_cast< int >(val2);
24149 if (obj2) {
24150 ecode3 = SWIG_AsVal_int(obj2, &val3);
24151 if (!SWIG_IsOK(ecode3)) {
24152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24153 }
24154 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24155 }
24156 {
24157 PyThreadState* __tstate = wxPyBeginAllowThreads();
24158 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24159 wxPyEndAllowThreads(__tstate);
24160 if (PyErr_Occurred()) SWIG_fail;
24161 }
24162 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24163 return resultobj;
24164 fail:
24165 return NULL;
24166 }
24167
24168
24169 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24170 PyObject *resultobj = 0;
24171 wxDateTime *arg1 = (wxDateTime *) 0 ;
24172 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24173 int arg3 = (int) wxDateTime::Inv_Year ;
24174 wxDateTime *result = 0 ;
24175 void *argp1 = 0 ;
24176 int res1 = 0 ;
24177 int val2 ;
24178 int ecode2 = 0 ;
24179 int val3 ;
24180 int ecode3 = 0 ;
24181 PyObject * obj0 = 0 ;
24182 PyObject * obj1 = 0 ;
24183 PyObject * obj2 = 0 ;
24184 char * kwnames[] = {
24185 (char *) "self",(char *) "month",(char *) "year", NULL
24186 };
24187
24188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24190 if (!SWIG_IsOK(res1)) {
24191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24192 }
24193 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24194 if (obj1) {
24195 ecode2 = SWIG_AsVal_int(obj1, &val2);
24196 if (!SWIG_IsOK(ecode2)) {
24197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24198 }
24199 arg2 = static_cast< wxDateTime::Month >(val2);
24200 }
24201 if (obj2) {
24202 ecode3 = SWIG_AsVal_int(obj2, &val3);
24203 if (!SWIG_IsOK(ecode3)) {
24204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24205 }
24206 arg3 = static_cast< int >(val3);
24207 }
24208 {
24209 PyThreadState* __tstate = wxPyBeginAllowThreads();
24210 {
24211 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24212 result = (wxDateTime *) &_result_ref;
24213 }
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj = 0;
24226 wxDateTime *arg1 = (wxDateTime *) 0 ;
24227 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24228 int arg3 = (int) wxDateTime::Inv_Year ;
24229 wxDateTime result;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 int val2 ;
24233 int ecode2 = 0 ;
24234 int val3 ;
24235 int ecode3 = 0 ;
24236 PyObject * obj0 = 0 ;
24237 PyObject * obj1 = 0 ;
24238 PyObject * obj2 = 0 ;
24239 char * kwnames[] = {
24240 (char *) "self",(char *) "month",(char *) "year", NULL
24241 };
24242
24243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24245 if (!SWIG_IsOK(res1)) {
24246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24247 }
24248 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24249 if (obj1) {
24250 ecode2 = SWIG_AsVal_int(obj1, &val2);
24251 if (!SWIG_IsOK(ecode2)) {
24252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24253 }
24254 arg2 = static_cast< wxDateTime::Month >(val2);
24255 }
24256 if (obj2) {
24257 ecode3 = SWIG_AsVal_int(obj2, &val3);
24258 if (!SWIG_IsOK(ecode3)) {
24259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24260 }
24261 arg3 = static_cast< int >(val3);
24262 }
24263 {
24264 PyThreadState* __tstate = wxPyBeginAllowThreads();
24265 result = (arg1)->GetLastMonthDay(arg2,arg3);
24266 wxPyEndAllowThreads(__tstate);
24267 if (PyErr_Occurred()) SWIG_fail;
24268 }
24269 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24270 return resultobj;
24271 fail:
24272 return NULL;
24273 }
24274
24275
24276 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24277 PyObject *resultobj = 0;
24278 wxDateTime *arg1 = (wxDateTime *) 0 ;
24279 int arg2 ;
24280 wxDateTime *result = 0 ;
24281 void *argp1 = 0 ;
24282 int res1 = 0 ;
24283 int val2 ;
24284 int ecode2 = 0 ;
24285 PyObject * obj0 = 0 ;
24286 PyObject * obj1 = 0 ;
24287 char * kwnames[] = {
24288 (char *) "self",(char *) "yday", NULL
24289 };
24290
24291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24293 if (!SWIG_IsOK(res1)) {
24294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24295 }
24296 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24297 ecode2 = SWIG_AsVal_int(obj1, &val2);
24298 if (!SWIG_IsOK(ecode2)) {
24299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24300 }
24301 arg2 = static_cast< int >(val2);
24302 {
24303 PyThreadState* __tstate = wxPyBeginAllowThreads();
24304 {
24305 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24306 result = (wxDateTime *) &_result_ref;
24307 }
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24312 return resultobj;
24313 fail:
24314 return NULL;
24315 }
24316
24317
24318 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24319 PyObject *resultobj = 0;
24320 wxDateTime *arg1 = (wxDateTime *) 0 ;
24321 int arg2 ;
24322 wxDateTime result;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 int val2 ;
24326 int ecode2 = 0 ;
24327 PyObject * obj0 = 0 ;
24328 PyObject * obj1 = 0 ;
24329 char * kwnames[] = {
24330 (char *) "self",(char *) "yday", NULL
24331 };
24332
24333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24335 if (!SWIG_IsOK(res1)) {
24336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24337 }
24338 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24339 ecode2 = SWIG_AsVal_int(obj1, &val2);
24340 if (!SWIG_IsOK(ecode2)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24342 }
24343 arg2 = static_cast< int >(val2);
24344 {
24345 PyThreadState* __tstate = wxPyBeginAllowThreads();
24346 result = (arg1)->GetYearDay(arg2);
24347 wxPyEndAllowThreads(__tstate);
24348 if (PyErr_Occurred()) SWIG_fail;
24349 }
24350 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24351 return resultobj;
24352 fail:
24353 return NULL;
24354 }
24355
24356
24357 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24358 PyObject *resultobj = 0;
24359 wxDateTime *arg1 = (wxDateTime *) 0 ;
24360 double result;
24361 void *argp1 = 0 ;
24362 int res1 = 0 ;
24363 PyObject *swig_obj[1] ;
24364
24365 if (!args) SWIG_fail;
24366 swig_obj[0] = args;
24367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24368 if (!SWIG_IsOK(res1)) {
24369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24370 }
24371 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24372 {
24373 PyThreadState* __tstate = wxPyBeginAllowThreads();
24374 result = (double)(arg1)->GetJulianDayNumber();
24375 wxPyEndAllowThreads(__tstate);
24376 if (PyErr_Occurred()) SWIG_fail;
24377 }
24378 resultobj = SWIG_From_double(static_cast< double >(result));
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24386 PyObject *resultobj = 0;
24387 wxDateTime *arg1 = (wxDateTime *) 0 ;
24388 double result;
24389 void *argp1 = 0 ;
24390 int res1 = 0 ;
24391 PyObject *swig_obj[1] ;
24392
24393 if (!args) SWIG_fail;
24394 swig_obj[0] = args;
24395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24396 if (!SWIG_IsOK(res1)) {
24397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24398 }
24399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24400 {
24401 PyThreadState* __tstate = wxPyBeginAllowThreads();
24402 result = (double)(arg1)->GetJDN();
24403 wxPyEndAllowThreads(__tstate);
24404 if (PyErr_Occurred()) SWIG_fail;
24405 }
24406 resultobj = SWIG_From_double(static_cast< double >(result));
24407 return resultobj;
24408 fail:
24409 return NULL;
24410 }
24411
24412
24413 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24414 PyObject *resultobj = 0;
24415 wxDateTime *arg1 = (wxDateTime *) 0 ;
24416 double result;
24417 void *argp1 = 0 ;
24418 int res1 = 0 ;
24419 PyObject *swig_obj[1] ;
24420
24421 if (!args) SWIG_fail;
24422 swig_obj[0] = args;
24423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24424 if (!SWIG_IsOK(res1)) {
24425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24426 }
24427 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24428 {
24429 PyThreadState* __tstate = wxPyBeginAllowThreads();
24430 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24431 wxPyEndAllowThreads(__tstate);
24432 if (PyErr_Occurred()) SWIG_fail;
24433 }
24434 resultobj = SWIG_From_double(static_cast< double >(result));
24435 return resultobj;
24436 fail:
24437 return NULL;
24438 }
24439
24440
24441 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24442 PyObject *resultobj = 0;
24443 wxDateTime *arg1 = (wxDateTime *) 0 ;
24444 double result;
24445 void *argp1 = 0 ;
24446 int res1 = 0 ;
24447 PyObject *swig_obj[1] ;
24448
24449 if (!args) SWIG_fail;
24450 swig_obj[0] = args;
24451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24452 if (!SWIG_IsOK(res1)) {
24453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24454 }
24455 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24456 {
24457 PyThreadState* __tstate = wxPyBeginAllowThreads();
24458 result = (double)(arg1)->GetMJD();
24459 wxPyEndAllowThreads(__tstate);
24460 if (PyErr_Occurred()) SWIG_fail;
24461 }
24462 resultobj = SWIG_From_double(static_cast< double >(result));
24463 return resultobj;
24464 fail:
24465 return NULL;
24466 }
24467
24468
24469 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24470 PyObject *resultobj = 0;
24471 wxDateTime *arg1 = (wxDateTime *) 0 ;
24472 double result;
24473 void *argp1 = 0 ;
24474 int res1 = 0 ;
24475 PyObject *swig_obj[1] ;
24476
24477 if (!args) SWIG_fail;
24478 swig_obj[0] = args;
24479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24480 if (!SWIG_IsOK(res1)) {
24481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24482 }
24483 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24484 {
24485 PyThreadState* __tstate = wxPyBeginAllowThreads();
24486 result = (double)(arg1)->GetRataDie();
24487 wxPyEndAllowThreads(__tstate);
24488 if (PyErr_Occurred()) SWIG_fail;
24489 }
24490 resultobj = SWIG_From_double(static_cast< double >(result));
24491 return resultobj;
24492 fail:
24493 return NULL;
24494 }
24495
24496
24497 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24498 PyObject *resultobj = 0;
24499 wxDateTime *arg1 = (wxDateTime *) 0 ;
24500 wxDateTime::TimeZone *arg2 = 0 ;
24501 bool arg3 = (bool) false ;
24502 wxDateTime result;
24503 void *argp1 = 0 ;
24504 int res1 = 0 ;
24505 bool temp2 = false ;
24506 bool val3 ;
24507 int ecode3 = 0 ;
24508 PyObject * obj0 = 0 ;
24509 PyObject * obj1 = 0 ;
24510 PyObject * obj2 = 0 ;
24511 char * kwnames[] = {
24512 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24513 };
24514
24515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24517 if (!SWIG_IsOK(res1)) {
24518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24519 }
24520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24521 {
24522 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24523 temp2 = true;
24524 }
24525 if (obj2) {
24526 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24527 if (!SWIG_IsOK(ecode3)) {
24528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24529 }
24530 arg3 = static_cast< bool >(val3);
24531 }
24532 {
24533 PyThreadState* __tstate = wxPyBeginAllowThreads();
24534 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24535 wxPyEndAllowThreads(__tstate);
24536 if (PyErr_Occurred()) SWIG_fail;
24537 }
24538 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24539 {
24540 if (temp2) delete arg2;
24541 }
24542 return resultobj;
24543 fail:
24544 {
24545 if (temp2) delete arg2;
24546 }
24547 return NULL;
24548 }
24549
24550
24551 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24552 PyObject *resultobj = 0;
24553 wxDateTime *arg1 = (wxDateTime *) 0 ;
24554 wxDateTime::TimeZone *arg2 = 0 ;
24555 bool arg3 = (bool) false ;
24556 wxDateTime *result = 0 ;
24557 void *argp1 = 0 ;
24558 int res1 = 0 ;
24559 bool temp2 = false ;
24560 bool val3 ;
24561 int ecode3 = 0 ;
24562 PyObject * obj0 = 0 ;
24563 PyObject * obj1 = 0 ;
24564 PyObject * obj2 = 0 ;
24565 char * kwnames[] = {
24566 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24567 };
24568
24569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24571 if (!SWIG_IsOK(res1)) {
24572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24573 }
24574 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24575 {
24576 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24577 temp2 = true;
24578 }
24579 if (obj2) {
24580 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24581 if (!SWIG_IsOK(ecode3)) {
24582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24583 }
24584 arg3 = static_cast< bool >(val3);
24585 }
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 {
24589 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24590 result = (wxDateTime *) &_result_ref;
24591 }
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24596 {
24597 if (temp2) delete arg2;
24598 }
24599 return resultobj;
24600 fail:
24601 {
24602 if (temp2) delete arg2;
24603 }
24604 return NULL;
24605 }
24606
24607
24608 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24609 PyObject *resultobj = 0;
24610 wxDateTime *arg1 = (wxDateTime *) 0 ;
24611 wxDateTime::TimeZone *arg2 = 0 ;
24612 bool arg3 = (bool) false ;
24613 wxDateTime result;
24614 void *argp1 = 0 ;
24615 int res1 = 0 ;
24616 bool temp2 = false ;
24617 bool val3 ;
24618 int ecode3 = 0 ;
24619 PyObject * obj0 = 0 ;
24620 PyObject * obj1 = 0 ;
24621 PyObject * obj2 = 0 ;
24622 char * kwnames[] = {
24623 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24624 };
24625
24626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24628 if (!SWIG_IsOK(res1)) {
24629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24630 }
24631 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24632 {
24633 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24634 temp2 = true;
24635 }
24636 if (obj2) {
24637 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24638 if (!SWIG_IsOK(ecode3)) {
24639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24640 }
24641 arg3 = static_cast< bool >(val3);
24642 }
24643 {
24644 PyThreadState* __tstate = wxPyBeginAllowThreads();
24645 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24646 wxPyEndAllowThreads(__tstate);
24647 if (PyErr_Occurred()) SWIG_fail;
24648 }
24649 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24650 {
24651 if (temp2) delete arg2;
24652 }
24653 return resultobj;
24654 fail:
24655 {
24656 if (temp2) delete arg2;
24657 }
24658 return NULL;
24659 }
24660
24661
24662 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj = 0;
24664 wxDateTime *arg1 = (wxDateTime *) 0 ;
24665 wxDateTime::TimeZone *arg2 = 0 ;
24666 bool arg3 = (bool) false ;
24667 wxDateTime *result = 0 ;
24668 void *argp1 = 0 ;
24669 int res1 = 0 ;
24670 bool temp2 = false ;
24671 bool val3 ;
24672 int ecode3 = 0 ;
24673 PyObject * obj0 = 0 ;
24674 PyObject * obj1 = 0 ;
24675 PyObject * obj2 = 0 ;
24676 char * kwnames[] = {
24677 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24678 };
24679
24680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24682 if (!SWIG_IsOK(res1)) {
24683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24684 }
24685 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24686 {
24687 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24688 temp2 = true;
24689 }
24690 if (obj2) {
24691 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24692 if (!SWIG_IsOK(ecode3)) {
24693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24694 }
24695 arg3 = static_cast< bool >(val3);
24696 }
24697 {
24698 PyThreadState* __tstate = wxPyBeginAllowThreads();
24699 {
24700 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24701 result = (wxDateTime *) &_result_ref;
24702 }
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24707 {
24708 if (temp2) delete arg2;
24709 }
24710 return resultobj;
24711 fail:
24712 {
24713 if (temp2) delete arg2;
24714 }
24715 return NULL;
24716 }
24717
24718
24719 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24720 PyObject *resultobj = 0;
24721 wxDateTime *arg1 = (wxDateTime *) 0 ;
24722 bool arg2 = (bool) false ;
24723 wxDateTime result;
24724 void *argp1 = 0 ;
24725 int res1 = 0 ;
24726 bool val2 ;
24727 int ecode2 = 0 ;
24728 PyObject * obj0 = 0 ;
24729 PyObject * obj1 = 0 ;
24730 char * kwnames[] = {
24731 (char *) "self",(char *) "noDST", NULL
24732 };
24733
24734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24736 if (!SWIG_IsOK(res1)) {
24737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24738 }
24739 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24740 if (obj1) {
24741 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24742 if (!SWIG_IsOK(ecode2)) {
24743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24744 }
24745 arg2 = static_cast< bool >(val2);
24746 }
24747 {
24748 PyThreadState* __tstate = wxPyBeginAllowThreads();
24749 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24761 PyObject *resultobj = 0;
24762 wxDateTime *arg1 = (wxDateTime *) 0 ;
24763 bool arg2 = (bool) false ;
24764 wxDateTime *result = 0 ;
24765 void *argp1 = 0 ;
24766 int res1 = 0 ;
24767 bool val2 ;
24768 int ecode2 = 0 ;
24769 PyObject * obj0 = 0 ;
24770 PyObject * obj1 = 0 ;
24771 char * kwnames[] = {
24772 (char *) "self",(char *) "noDST", NULL
24773 };
24774
24775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24777 if (!SWIG_IsOK(res1)) {
24778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24779 }
24780 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24781 if (obj1) {
24782 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24783 if (!SWIG_IsOK(ecode2)) {
24784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24785 }
24786 arg2 = static_cast< bool >(val2);
24787 }
24788 {
24789 PyThreadState* __tstate = wxPyBeginAllowThreads();
24790 {
24791 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24792 result = (wxDateTime *) &_result_ref;
24793 }
24794 wxPyEndAllowThreads(__tstate);
24795 if (PyErr_Occurred()) SWIG_fail;
24796 }
24797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24798 return resultobj;
24799 fail:
24800 return NULL;
24801 }
24802
24803
24804 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24805 PyObject *resultobj = 0;
24806 wxDateTime *arg1 = (wxDateTime *) 0 ;
24807 bool arg2 = (bool) false ;
24808 wxDateTime result;
24809 void *argp1 = 0 ;
24810 int res1 = 0 ;
24811 bool val2 ;
24812 int ecode2 = 0 ;
24813 PyObject * obj0 = 0 ;
24814 PyObject * obj1 = 0 ;
24815 char * kwnames[] = {
24816 (char *) "self",(char *) "noDST", NULL
24817 };
24818
24819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24821 if (!SWIG_IsOK(res1)) {
24822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24823 }
24824 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24825 if (obj1) {
24826 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24827 if (!SWIG_IsOK(ecode2)) {
24828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24829 }
24830 arg2 = static_cast< bool >(val2);
24831 }
24832 {
24833 PyThreadState* __tstate = wxPyBeginAllowThreads();
24834 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24835 wxPyEndAllowThreads(__tstate);
24836 if (PyErr_Occurred()) SWIG_fail;
24837 }
24838 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24846 PyObject *resultobj = 0;
24847 wxDateTime *arg1 = (wxDateTime *) 0 ;
24848 bool arg2 = (bool) false ;
24849 wxDateTime *result = 0 ;
24850 void *argp1 = 0 ;
24851 int res1 = 0 ;
24852 bool val2 ;
24853 int ecode2 = 0 ;
24854 PyObject * obj0 = 0 ;
24855 PyObject * obj1 = 0 ;
24856 char * kwnames[] = {
24857 (char *) "self",(char *) "noDST", NULL
24858 };
24859
24860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24862 if (!SWIG_IsOK(res1)) {
24863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24864 }
24865 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24866 if (obj1) {
24867 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24868 if (!SWIG_IsOK(ecode2)) {
24869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24870 }
24871 arg2 = static_cast< bool >(val2);
24872 }
24873 {
24874 PyThreadState* __tstate = wxPyBeginAllowThreads();
24875 {
24876 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24877 result = (wxDateTime *) &_result_ref;
24878 }
24879 wxPyEndAllowThreads(__tstate);
24880 if (PyErr_Occurred()) SWIG_fail;
24881 }
24882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24883 return resultobj;
24884 fail:
24885 return NULL;
24886 }
24887
24888
24889 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24890 PyObject *resultobj = 0;
24891 wxDateTime *arg1 = (wxDateTime *) 0 ;
24892 bool arg2 = (bool) false ;
24893 wxDateTime result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 bool val2 ;
24897 int ecode2 = 0 ;
24898 PyObject * obj0 = 0 ;
24899 PyObject * obj1 = 0 ;
24900 char * kwnames[] = {
24901 (char *) "self",(char *) "noDST", NULL
24902 };
24903
24904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24906 if (!SWIG_IsOK(res1)) {
24907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24908 }
24909 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24910 if (obj1) {
24911 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24912 if (!SWIG_IsOK(ecode2)) {
24913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24914 }
24915 arg2 = static_cast< bool >(val2);
24916 }
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24931 PyObject *resultobj = 0;
24932 wxDateTime *arg1 = (wxDateTime *) 0 ;
24933 bool arg2 = (bool) false ;
24934 wxDateTime *result = 0 ;
24935 void *argp1 = 0 ;
24936 int res1 = 0 ;
24937 bool val2 ;
24938 int ecode2 = 0 ;
24939 PyObject * obj0 = 0 ;
24940 PyObject * obj1 = 0 ;
24941 char * kwnames[] = {
24942 (char *) "self",(char *) "noDST", NULL
24943 };
24944
24945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24947 if (!SWIG_IsOK(res1)) {
24948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24949 }
24950 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24951 if (obj1) {
24952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24953 if (!SWIG_IsOK(ecode2)) {
24954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24955 }
24956 arg2 = static_cast< bool >(val2);
24957 }
24958 {
24959 PyThreadState* __tstate = wxPyBeginAllowThreads();
24960 {
24961 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24962 result = (wxDateTime *) &_result_ref;
24963 }
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24968 return resultobj;
24969 fail:
24970 return NULL;
24971 }
24972
24973
24974 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24975 PyObject *resultobj = 0;
24976 wxDateTime *arg1 = (wxDateTime *) 0 ;
24977 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24978 int result;
24979 void *argp1 = 0 ;
24980 int res1 = 0 ;
24981 int val2 ;
24982 int ecode2 = 0 ;
24983 PyObject * obj0 = 0 ;
24984 PyObject * obj1 = 0 ;
24985 char * kwnames[] = {
24986 (char *) "self",(char *) "country", NULL
24987 };
24988
24989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24991 if (!SWIG_IsOK(res1)) {
24992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24993 }
24994 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24995 if (obj1) {
24996 ecode2 = SWIG_AsVal_int(obj1, &val2);
24997 if (!SWIG_IsOK(ecode2)) {
24998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24999 }
25000 arg2 = static_cast< wxDateTime::Country >(val2);
25001 }
25002 {
25003 PyThreadState* __tstate = wxPyBeginAllowThreads();
25004 result = (int)(arg1)->IsDST(arg2);
25005 wxPyEndAllowThreads(__tstate);
25006 if (PyErr_Occurred()) SWIG_fail;
25007 }
25008 resultobj = SWIG_From_int(static_cast< int >(result));
25009 return resultobj;
25010 fail:
25011 return NULL;
25012 }
25013
25014
25015 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25016 PyObject *resultobj = 0;
25017 wxDateTime *arg1 = (wxDateTime *) 0 ;
25018 bool result;
25019 void *argp1 = 0 ;
25020 int res1 = 0 ;
25021 PyObject *swig_obj[1] ;
25022
25023 if (!args) SWIG_fail;
25024 swig_obj[0] = args;
25025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25026 if (!SWIG_IsOK(res1)) {
25027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25028 }
25029 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25030 {
25031 PyThreadState* __tstate = wxPyBeginAllowThreads();
25032 result = (bool)((wxDateTime const *)arg1)->IsValid();
25033 wxPyEndAllowThreads(__tstate);
25034 if (PyErr_Occurred()) SWIG_fail;
25035 }
25036 {
25037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25038 }
25039 return resultobj;
25040 fail:
25041 return NULL;
25042 }
25043
25044
25045 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25046 PyObject *resultobj = 0;
25047 wxDateTime *arg1 = (wxDateTime *) 0 ;
25048 time_t result;
25049 void *argp1 = 0 ;
25050 int res1 = 0 ;
25051 PyObject *swig_obj[1] ;
25052
25053 if (!args) SWIG_fail;
25054 swig_obj[0] = args;
25055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25056 if (!SWIG_IsOK(res1)) {
25057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25058 }
25059 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj = 0;
25075 wxDateTime *arg1 = (wxDateTime *) 0 ;
25076 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25077 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25078 int result;
25079 void *argp1 = 0 ;
25080 int res1 = 0 ;
25081 bool temp2 = false ;
25082 PyObject * obj0 = 0 ;
25083 PyObject * obj1 = 0 ;
25084 char * kwnames[] = {
25085 (char *) "self",(char *) "tz", NULL
25086 };
25087
25088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
25089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25090 if (!SWIG_IsOK(res1)) {
25091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25092 }
25093 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25094 if (obj1) {
25095 {
25096 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25097 temp2 = true;
25098 }
25099 }
25100 {
25101 PyThreadState* __tstate = wxPyBeginAllowThreads();
25102 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
25103 wxPyEndAllowThreads(__tstate);
25104 if (PyErr_Occurred()) SWIG_fail;
25105 }
25106 resultobj = SWIG_From_int(static_cast< int >(result));
25107 {
25108 if (temp2) delete arg2;
25109 }
25110 return resultobj;
25111 fail:
25112 {
25113 if (temp2) delete arg2;
25114 }
25115 return NULL;
25116 }
25117
25118
25119 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25120 PyObject *resultobj = 0;
25121 wxDateTime *arg1 = (wxDateTime *) 0 ;
25122 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25123 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25124 wxDateTime::Month result;
25125 void *argp1 = 0 ;
25126 int res1 = 0 ;
25127 bool temp2 = false ;
25128 PyObject * obj0 = 0 ;
25129 PyObject * obj1 = 0 ;
25130 char * kwnames[] = {
25131 (char *) "self",(char *) "tz", NULL
25132 };
25133
25134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25136 if (!SWIG_IsOK(res1)) {
25137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25138 }
25139 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25140 if (obj1) {
25141 {
25142 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25143 temp2 = true;
25144 }
25145 }
25146 {
25147 PyThreadState* __tstate = wxPyBeginAllowThreads();
25148 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25149 wxPyEndAllowThreads(__tstate);
25150 if (PyErr_Occurred()) SWIG_fail;
25151 }
25152 resultobj = SWIG_From_int(static_cast< int >(result));
25153 {
25154 if (temp2) delete arg2;
25155 }
25156 return resultobj;
25157 fail:
25158 {
25159 if (temp2) delete arg2;
25160 }
25161 return NULL;
25162 }
25163
25164
25165 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25166 PyObject *resultobj = 0;
25167 wxDateTime *arg1 = (wxDateTime *) 0 ;
25168 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25169 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25170 int result;
25171 void *argp1 = 0 ;
25172 int res1 = 0 ;
25173 bool temp2 = false ;
25174 PyObject * obj0 = 0 ;
25175 PyObject * obj1 = 0 ;
25176 char * kwnames[] = {
25177 (char *) "self",(char *) "tz", NULL
25178 };
25179
25180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25182 if (!SWIG_IsOK(res1)) {
25183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25184 }
25185 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25186 if (obj1) {
25187 {
25188 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25189 temp2 = true;
25190 }
25191 }
25192 {
25193 PyThreadState* __tstate = wxPyBeginAllowThreads();
25194 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25195 wxPyEndAllowThreads(__tstate);
25196 if (PyErr_Occurred()) SWIG_fail;
25197 }
25198 resultobj = SWIG_From_int(static_cast< int >(result));
25199 {
25200 if (temp2) delete arg2;
25201 }
25202 return resultobj;
25203 fail:
25204 {
25205 if (temp2) delete arg2;
25206 }
25207 return NULL;
25208 }
25209
25210
25211 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25212 PyObject *resultobj = 0;
25213 wxDateTime *arg1 = (wxDateTime *) 0 ;
25214 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25215 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25216 wxDateTime::WeekDay result;
25217 void *argp1 = 0 ;
25218 int res1 = 0 ;
25219 bool temp2 = false ;
25220 PyObject * obj0 = 0 ;
25221 PyObject * obj1 = 0 ;
25222 char * kwnames[] = {
25223 (char *) "self",(char *) "tz", NULL
25224 };
25225
25226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25228 if (!SWIG_IsOK(res1)) {
25229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25230 }
25231 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25232 if (obj1) {
25233 {
25234 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25235 temp2 = true;
25236 }
25237 }
25238 {
25239 PyThreadState* __tstate = wxPyBeginAllowThreads();
25240 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25241 wxPyEndAllowThreads(__tstate);
25242 if (PyErr_Occurred()) SWIG_fail;
25243 }
25244 resultobj = SWIG_From_int(static_cast< int >(result));
25245 {
25246 if (temp2) delete arg2;
25247 }
25248 return resultobj;
25249 fail:
25250 {
25251 if (temp2) delete arg2;
25252 }
25253 return NULL;
25254 }
25255
25256
25257 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25258 PyObject *resultobj = 0;
25259 wxDateTime *arg1 = (wxDateTime *) 0 ;
25260 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25261 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25262 int result;
25263 void *argp1 = 0 ;
25264 int res1 = 0 ;
25265 bool temp2 = false ;
25266 PyObject * obj0 = 0 ;
25267 PyObject * obj1 = 0 ;
25268 char * kwnames[] = {
25269 (char *) "self",(char *) "tz", NULL
25270 };
25271
25272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25274 if (!SWIG_IsOK(res1)) {
25275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25276 }
25277 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25278 if (obj1) {
25279 {
25280 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25281 temp2 = true;
25282 }
25283 }
25284 {
25285 PyThreadState* __tstate = wxPyBeginAllowThreads();
25286 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25287 wxPyEndAllowThreads(__tstate);
25288 if (PyErr_Occurred()) SWIG_fail;
25289 }
25290 resultobj = SWIG_From_int(static_cast< int >(result));
25291 {
25292 if (temp2) delete arg2;
25293 }
25294 return resultobj;
25295 fail:
25296 {
25297 if (temp2) delete arg2;
25298 }
25299 return NULL;
25300 }
25301
25302
25303 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25304 PyObject *resultobj = 0;
25305 wxDateTime *arg1 = (wxDateTime *) 0 ;
25306 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25307 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25308 int result;
25309 void *argp1 = 0 ;
25310 int res1 = 0 ;
25311 bool temp2 = false ;
25312 PyObject * obj0 = 0 ;
25313 PyObject * obj1 = 0 ;
25314 char * kwnames[] = {
25315 (char *) "self",(char *) "tz", NULL
25316 };
25317
25318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25320 if (!SWIG_IsOK(res1)) {
25321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25322 }
25323 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25324 if (obj1) {
25325 {
25326 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25327 temp2 = true;
25328 }
25329 }
25330 {
25331 PyThreadState* __tstate = wxPyBeginAllowThreads();
25332 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 resultobj = SWIG_From_int(static_cast< int >(result));
25337 {
25338 if (temp2) delete arg2;
25339 }
25340 return resultobj;
25341 fail:
25342 {
25343 if (temp2) delete arg2;
25344 }
25345 return NULL;
25346 }
25347
25348
25349 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj = 0;
25351 wxDateTime *arg1 = (wxDateTime *) 0 ;
25352 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25353 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25354 int result;
25355 void *argp1 = 0 ;
25356 int res1 = 0 ;
25357 bool temp2 = false ;
25358 PyObject * obj0 = 0 ;
25359 PyObject * obj1 = 0 ;
25360 char * kwnames[] = {
25361 (char *) "self",(char *) "tz", NULL
25362 };
25363
25364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25366 if (!SWIG_IsOK(res1)) {
25367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25368 }
25369 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25370 if (obj1) {
25371 {
25372 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25373 temp2 = true;
25374 }
25375 }
25376 {
25377 PyThreadState* __tstate = wxPyBeginAllowThreads();
25378 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25379 wxPyEndAllowThreads(__tstate);
25380 if (PyErr_Occurred()) SWIG_fail;
25381 }
25382 resultobj = SWIG_From_int(static_cast< int >(result));
25383 {
25384 if (temp2) delete arg2;
25385 }
25386 return resultobj;
25387 fail:
25388 {
25389 if (temp2) delete arg2;
25390 }
25391 return NULL;
25392 }
25393
25394
25395 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25396 PyObject *resultobj = 0;
25397 wxDateTime *arg1 = (wxDateTime *) 0 ;
25398 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25399 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25400 int result;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 bool temp2 = false ;
25404 PyObject * obj0 = 0 ;
25405 PyObject * obj1 = 0 ;
25406 char * kwnames[] = {
25407 (char *) "self",(char *) "tz", NULL
25408 };
25409
25410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25412 if (!SWIG_IsOK(res1)) {
25413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25414 }
25415 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25416 if (obj1) {
25417 {
25418 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25419 temp2 = true;
25420 }
25421 }
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_From_int(static_cast< int >(result));
25429 {
25430 if (temp2) delete arg2;
25431 }
25432 return resultobj;
25433 fail:
25434 {
25435 if (temp2) delete arg2;
25436 }
25437 return NULL;
25438 }
25439
25440
25441 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25442 PyObject *resultobj = 0;
25443 wxDateTime *arg1 = (wxDateTime *) 0 ;
25444 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25445 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25446 int result;
25447 void *argp1 = 0 ;
25448 int res1 = 0 ;
25449 bool temp2 = false ;
25450 PyObject * obj0 = 0 ;
25451 PyObject * obj1 = 0 ;
25452 char * kwnames[] = {
25453 (char *) "self",(char *) "tz", NULL
25454 };
25455
25456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25458 if (!SWIG_IsOK(res1)) {
25459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25460 }
25461 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25462 if (obj1) {
25463 {
25464 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25465 temp2 = true;
25466 }
25467 }
25468 {
25469 PyThreadState* __tstate = wxPyBeginAllowThreads();
25470 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25471 wxPyEndAllowThreads(__tstate);
25472 if (PyErr_Occurred()) SWIG_fail;
25473 }
25474 resultobj = SWIG_From_int(static_cast< int >(result));
25475 {
25476 if (temp2) delete arg2;
25477 }
25478 return resultobj;
25479 fail:
25480 {
25481 if (temp2) delete arg2;
25482 }
25483 return NULL;
25484 }
25485
25486
25487 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25488 PyObject *resultobj = 0;
25489 wxDateTime *arg1 = (wxDateTime *) 0 ;
25490 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25491 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25492 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25493 int result;
25494 void *argp1 = 0 ;
25495 int res1 = 0 ;
25496 int val2 ;
25497 int ecode2 = 0 ;
25498 bool temp3 = false ;
25499 PyObject * obj0 = 0 ;
25500 PyObject * obj1 = 0 ;
25501 PyObject * obj2 = 0 ;
25502 char * kwnames[] = {
25503 (char *) "self",(char *) "flags",(char *) "tz", NULL
25504 };
25505
25506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25508 if (!SWIG_IsOK(res1)) {
25509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25510 }
25511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25512 if (obj1) {
25513 ecode2 = SWIG_AsVal_int(obj1, &val2);
25514 if (!SWIG_IsOK(ecode2)) {
25515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25516 }
25517 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25518 }
25519 if (obj2) {
25520 {
25521 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25522 temp3 = true;
25523 }
25524 }
25525 {
25526 PyThreadState* __tstate = wxPyBeginAllowThreads();
25527 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25528 wxPyEndAllowThreads(__tstate);
25529 if (PyErr_Occurred()) SWIG_fail;
25530 }
25531 resultobj = SWIG_From_int(static_cast< int >(result));
25532 {
25533 if (temp3) delete arg3;
25534 }
25535 return resultobj;
25536 fail:
25537 {
25538 if (temp3) delete arg3;
25539 }
25540 return NULL;
25541 }
25542
25543
25544 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25545 PyObject *resultobj = 0;
25546 wxDateTime *arg1 = (wxDateTime *) 0 ;
25547 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25548 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25549 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25550 int result;
25551 void *argp1 = 0 ;
25552 int res1 = 0 ;
25553 int val2 ;
25554 int ecode2 = 0 ;
25555 bool temp3 = false ;
25556 PyObject * obj0 = 0 ;
25557 PyObject * obj1 = 0 ;
25558 PyObject * obj2 = 0 ;
25559 char * kwnames[] = {
25560 (char *) "self",(char *) "flags",(char *) "tz", NULL
25561 };
25562
25563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25565 if (!SWIG_IsOK(res1)) {
25566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25567 }
25568 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25569 if (obj1) {
25570 ecode2 = SWIG_AsVal_int(obj1, &val2);
25571 if (!SWIG_IsOK(ecode2)) {
25572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25573 }
25574 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25575 }
25576 if (obj2) {
25577 {
25578 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25579 temp3 = true;
25580 }
25581 }
25582 {
25583 PyThreadState* __tstate = wxPyBeginAllowThreads();
25584 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25585 wxPyEndAllowThreads(__tstate);
25586 if (PyErr_Occurred()) SWIG_fail;
25587 }
25588 resultobj = SWIG_From_int(static_cast< int >(result));
25589 {
25590 if (temp3) delete arg3;
25591 }
25592 return resultobj;
25593 fail:
25594 {
25595 if (temp3) delete arg3;
25596 }
25597 return NULL;
25598 }
25599
25600
25601 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25602 PyObject *resultobj = 0;
25603 wxDateTime *arg1 = (wxDateTime *) 0 ;
25604 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25605 bool result;
25606 void *argp1 = 0 ;
25607 int res1 = 0 ;
25608 int val2 ;
25609 int ecode2 = 0 ;
25610 PyObject * obj0 = 0 ;
25611 PyObject * obj1 = 0 ;
25612 char * kwnames[] = {
25613 (char *) "self",(char *) "country", NULL
25614 };
25615
25616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25618 if (!SWIG_IsOK(res1)) {
25619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25620 }
25621 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25622 if (obj1) {
25623 ecode2 = SWIG_AsVal_int(obj1, &val2);
25624 if (!SWIG_IsOK(ecode2)) {
25625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25626 }
25627 arg2 = static_cast< wxDateTime::Country >(val2);
25628 }
25629 {
25630 PyThreadState* __tstate = wxPyBeginAllowThreads();
25631 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25632 wxPyEndAllowThreads(__tstate);
25633 if (PyErr_Occurred()) SWIG_fail;
25634 }
25635 {
25636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25637 }
25638 return resultobj;
25639 fail:
25640 return NULL;
25641 }
25642
25643
25644 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25645 PyObject *resultobj = 0;
25646 wxDateTime *arg1 = (wxDateTime *) 0 ;
25647 wxDateTime *arg2 = 0 ;
25648 bool result;
25649 void *argp1 = 0 ;
25650 int res1 = 0 ;
25651 void *argp2 = 0 ;
25652 int res2 = 0 ;
25653 PyObject * obj0 = 0 ;
25654 PyObject * obj1 = 0 ;
25655 char * kwnames[] = {
25656 (char *) "self",(char *) "datetime", NULL
25657 };
25658
25659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25661 if (!SWIG_IsOK(res1)) {
25662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25663 }
25664 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25665 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25666 if (!SWIG_IsOK(res2)) {
25667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25668 }
25669 if (!argp2) {
25670 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25671 }
25672 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25676 wxPyEndAllowThreads(__tstate);
25677 if (PyErr_Occurred()) SWIG_fail;
25678 }
25679 {
25680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25681 }
25682 return resultobj;
25683 fail:
25684 return NULL;
25685 }
25686
25687
25688 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25689 PyObject *resultobj = 0;
25690 wxDateTime *arg1 = (wxDateTime *) 0 ;
25691 wxDateTime *arg2 = 0 ;
25692 bool result;
25693 void *argp1 = 0 ;
25694 int res1 = 0 ;
25695 void *argp2 = 0 ;
25696 int res2 = 0 ;
25697 PyObject * obj0 = 0 ;
25698 PyObject * obj1 = 0 ;
25699 char * kwnames[] = {
25700 (char *) "self",(char *) "datetime", NULL
25701 };
25702
25703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25705 if (!SWIG_IsOK(res1)) {
25706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25707 }
25708 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25710 if (!SWIG_IsOK(res2)) {
25711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25712 }
25713 if (!argp2) {
25714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25715 }
25716 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25717 {
25718 PyThreadState* __tstate = wxPyBeginAllowThreads();
25719 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25720 wxPyEndAllowThreads(__tstate);
25721 if (PyErr_Occurred()) SWIG_fail;
25722 }
25723 {
25724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25725 }
25726 return resultobj;
25727 fail:
25728 return NULL;
25729 }
25730
25731
25732 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25733 PyObject *resultobj = 0;
25734 wxDateTime *arg1 = (wxDateTime *) 0 ;
25735 wxDateTime *arg2 = 0 ;
25736 bool result;
25737 void *argp1 = 0 ;
25738 int res1 = 0 ;
25739 void *argp2 = 0 ;
25740 int res2 = 0 ;
25741 PyObject * obj0 = 0 ;
25742 PyObject * obj1 = 0 ;
25743 char * kwnames[] = {
25744 (char *) "self",(char *) "datetime", NULL
25745 };
25746
25747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25749 if (!SWIG_IsOK(res1)) {
25750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25751 }
25752 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25753 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25754 if (!SWIG_IsOK(res2)) {
25755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25756 }
25757 if (!argp2) {
25758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25759 }
25760 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25761 {
25762 PyThreadState* __tstate = wxPyBeginAllowThreads();
25763 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 {
25768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25769 }
25770 return resultobj;
25771 fail:
25772 return NULL;
25773 }
25774
25775
25776 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25777 PyObject *resultobj = 0;
25778 wxDateTime *arg1 = (wxDateTime *) 0 ;
25779 wxDateTime *arg2 = 0 ;
25780 wxDateTime *arg3 = 0 ;
25781 bool result;
25782 void *argp1 = 0 ;
25783 int res1 = 0 ;
25784 void *argp2 = 0 ;
25785 int res2 = 0 ;
25786 void *argp3 = 0 ;
25787 int res3 = 0 ;
25788 PyObject * obj0 = 0 ;
25789 PyObject * obj1 = 0 ;
25790 PyObject * obj2 = 0 ;
25791 char * kwnames[] = {
25792 (char *) "self",(char *) "t1",(char *) "t2", NULL
25793 };
25794
25795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25797 if (!SWIG_IsOK(res1)) {
25798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25799 }
25800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25802 if (!SWIG_IsOK(res2)) {
25803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25804 }
25805 if (!argp2) {
25806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25807 }
25808 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25809 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25810 if (!SWIG_IsOK(res3)) {
25811 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25812 }
25813 if (!argp3) {
25814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25815 }
25816 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25820 wxPyEndAllowThreads(__tstate);
25821 if (PyErr_Occurred()) SWIG_fail;
25822 }
25823 {
25824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25825 }
25826 return resultobj;
25827 fail:
25828 return NULL;
25829 }
25830
25831
25832 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25833 PyObject *resultobj = 0;
25834 wxDateTime *arg1 = (wxDateTime *) 0 ;
25835 wxDateTime *arg2 = 0 ;
25836 wxDateTime *arg3 = 0 ;
25837 bool result;
25838 void *argp1 = 0 ;
25839 int res1 = 0 ;
25840 void *argp2 = 0 ;
25841 int res2 = 0 ;
25842 void *argp3 = 0 ;
25843 int res3 = 0 ;
25844 PyObject * obj0 = 0 ;
25845 PyObject * obj1 = 0 ;
25846 PyObject * obj2 = 0 ;
25847 char * kwnames[] = {
25848 (char *) "self",(char *) "t1",(char *) "t2", NULL
25849 };
25850
25851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25853 if (!SWIG_IsOK(res1)) {
25854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25855 }
25856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25858 if (!SWIG_IsOK(res2)) {
25859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25860 }
25861 if (!argp2) {
25862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25863 }
25864 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25865 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25866 if (!SWIG_IsOK(res3)) {
25867 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25868 }
25869 if (!argp3) {
25870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25871 }
25872 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25873 {
25874 PyThreadState* __tstate = wxPyBeginAllowThreads();
25875 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25876 wxPyEndAllowThreads(__tstate);
25877 if (PyErr_Occurred()) SWIG_fail;
25878 }
25879 {
25880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25881 }
25882 return resultobj;
25883 fail:
25884 return NULL;
25885 }
25886
25887
25888 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25889 PyObject *resultobj = 0;
25890 wxDateTime *arg1 = (wxDateTime *) 0 ;
25891 wxDateTime *arg2 = 0 ;
25892 bool result;
25893 void *argp1 = 0 ;
25894 int res1 = 0 ;
25895 void *argp2 = 0 ;
25896 int res2 = 0 ;
25897 PyObject * obj0 = 0 ;
25898 PyObject * obj1 = 0 ;
25899 char * kwnames[] = {
25900 (char *) "self",(char *) "dt", NULL
25901 };
25902
25903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25905 if (!SWIG_IsOK(res1)) {
25906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25907 }
25908 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25910 if (!SWIG_IsOK(res2)) {
25911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25912 }
25913 if (!argp2) {
25914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25915 }
25916 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25917 {
25918 PyThreadState* __tstate = wxPyBeginAllowThreads();
25919 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25920 wxPyEndAllowThreads(__tstate);
25921 if (PyErr_Occurred()) SWIG_fail;
25922 }
25923 {
25924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25925 }
25926 return resultobj;
25927 fail:
25928 return NULL;
25929 }
25930
25931
25932 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25933 PyObject *resultobj = 0;
25934 wxDateTime *arg1 = (wxDateTime *) 0 ;
25935 wxDateTime *arg2 = 0 ;
25936 bool result;
25937 void *argp1 = 0 ;
25938 int res1 = 0 ;
25939 void *argp2 = 0 ;
25940 int res2 = 0 ;
25941 PyObject * obj0 = 0 ;
25942 PyObject * obj1 = 0 ;
25943 char * kwnames[] = {
25944 (char *) "self",(char *) "dt", NULL
25945 };
25946
25947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25949 if (!SWIG_IsOK(res1)) {
25950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25951 }
25952 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25954 if (!SWIG_IsOK(res2)) {
25955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25956 }
25957 if (!argp2) {
25958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25959 }
25960 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25961 {
25962 PyThreadState* __tstate = wxPyBeginAllowThreads();
25963 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25964 wxPyEndAllowThreads(__tstate);
25965 if (PyErr_Occurred()) SWIG_fail;
25966 }
25967 {
25968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25969 }
25970 return resultobj;
25971 fail:
25972 return NULL;
25973 }
25974
25975
25976 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25977 PyObject *resultobj = 0;
25978 wxDateTime *arg1 = (wxDateTime *) 0 ;
25979 wxDateTime *arg2 = 0 ;
25980 wxTimeSpan *arg3 = 0 ;
25981 bool result;
25982 void *argp1 = 0 ;
25983 int res1 = 0 ;
25984 void *argp2 = 0 ;
25985 int res2 = 0 ;
25986 void *argp3 = 0 ;
25987 int res3 = 0 ;
25988 PyObject * obj0 = 0 ;
25989 PyObject * obj1 = 0 ;
25990 PyObject * obj2 = 0 ;
25991 char * kwnames[] = {
25992 (char *) "self",(char *) "dt",(char *) "ts", NULL
25993 };
25994
25995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25997 if (!SWIG_IsOK(res1)) {
25998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25999 }
26000 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26002 if (!SWIG_IsOK(res2)) {
26003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26004 }
26005 if (!argp2) {
26006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26007 }
26008 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26009 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26010 if (!SWIG_IsOK(res3)) {
26011 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26012 }
26013 if (!argp3) {
26014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26015 }
26016 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26017 {
26018 PyThreadState* __tstate = wxPyBeginAllowThreads();
26019 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26020 wxPyEndAllowThreads(__tstate);
26021 if (PyErr_Occurred()) SWIG_fail;
26022 }
26023 {
26024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26025 }
26026 return resultobj;
26027 fail:
26028 return NULL;
26029 }
26030
26031
26032 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26033 PyObject *resultobj = 0;
26034 wxDateTime *arg1 = (wxDateTime *) 0 ;
26035 wxTimeSpan *arg2 = 0 ;
26036 wxDateTime *result = 0 ;
26037 void *argp1 = 0 ;
26038 int res1 = 0 ;
26039 void *argp2 = 0 ;
26040 int res2 = 0 ;
26041 PyObject * obj0 = 0 ;
26042 PyObject * obj1 = 0 ;
26043 char * kwnames[] = {
26044 (char *) "self",(char *) "diff", NULL
26045 };
26046
26047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
26048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26049 if (!SWIG_IsOK(res1)) {
26050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26051 }
26052 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26054 if (!SWIG_IsOK(res2)) {
26055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26056 }
26057 if (!argp2) {
26058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26059 }
26060 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26061 {
26062 PyThreadState* __tstate = wxPyBeginAllowThreads();
26063 {
26064 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
26065 result = (wxDateTime *) &_result_ref;
26066 }
26067 wxPyEndAllowThreads(__tstate);
26068 if (PyErr_Occurred()) SWIG_fail;
26069 }
26070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26078 PyObject *resultobj = 0;
26079 wxDateTime *arg1 = (wxDateTime *) 0 ;
26080 wxDateSpan *arg2 = 0 ;
26081 wxDateTime *result = 0 ;
26082 void *argp1 = 0 ;
26083 int res1 = 0 ;
26084 void *argp2 = 0 ;
26085 int res2 = 0 ;
26086 PyObject * obj0 = 0 ;
26087 PyObject * obj1 = 0 ;
26088 char * kwnames[] = {
26089 (char *) "self",(char *) "diff", NULL
26090 };
26091
26092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
26093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26094 if (!SWIG_IsOK(res1)) {
26095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26096 }
26097 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26099 if (!SWIG_IsOK(res2)) {
26100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26101 }
26102 if (!argp2) {
26103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26104 }
26105 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26106 {
26107 PyThreadState* __tstate = wxPyBeginAllowThreads();
26108 {
26109 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26110 result = (wxDateTime *) &_result_ref;
26111 }
26112 wxPyEndAllowThreads(__tstate);
26113 if (PyErr_Occurred()) SWIG_fail;
26114 }
26115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26123 PyObject *resultobj = 0;
26124 wxDateTime *arg1 = (wxDateTime *) 0 ;
26125 wxTimeSpan *arg2 = 0 ;
26126 wxDateTime *result = 0 ;
26127 void *argp1 = 0 ;
26128 int res1 = 0 ;
26129 void *argp2 = 0 ;
26130 int res2 = 0 ;
26131 PyObject * obj0 = 0 ;
26132 PyObject * obj1 = 0 ;
26133 char * kwnames[] = {
26134 (char *) "self",(char *) "diff", NULL
26135 };
26136
26137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26139 if (!SWIG_IsOK(res1)) {
26140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26141 }
26142 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26143 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26144 if (!SWIG_IsOK(res2)) {
26145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26146 }
26147 if (!argp2) {
26148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26149 }
26150 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26151 {
26152 PyThreadState* __tstate = wxPyBeginAllowThreads();
26153 {
26154 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26155 result = (wxDateTime *) &_result_ref;
26156 }
26157 wxPyEndAllowThreads(__tstate);
26158 if (PyErr_Occurred()) SWIG_fail;
26159 }
26160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26168 PyObject *resultobj = 0;
26169 wxDateTime *arg1 = (wxDateTime *) 0 ;
26170 wxDateSpan *arg2 = 0 ;
26171 wxDateTime *result = 0 ;
26172 void *argp1 = 0 ;
26173 int res1 = 0 ;
26174 void *argp2 = 0 ;
26175 int res2 = 0 ;
26176 PyObject * obj0 = 0 ;
26177 PyObject * obj1 = 0 ;
26178 char * kwnames[] = {
26179 (char *) "self",(char *) "diff", NULL
26180 };
26181
26182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26184 if (!SWIG_IsOK(res1)) {
26185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26186 }
26187 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26188 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26189 if (!SWIG_IsOK(res2)) {
26190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26191 }
26192 if (!argp2) {
26193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26194 }
26195 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26196 {
26197 PyThreadState* __tstate = wxPyBeginAllowThreads();
26198 {
26199 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26200 result = (wxDateTime *) &_result_ref;
26201 }
26202 wxPyEndAllowThreads(__tstate);
26203 if (PyErr_Occurred()) SWIG_fail;
26204 }
26205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26206 return resultobj;
26207 fail:
26208 return NULL;
26209 }
26210
26211
26212 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26213 PyObject *resultobj = 0;
26214 wxDateTime *arg1 = (wxDateTime *) 0 ;
26215 wxDateTime *arg2 = 0 ;
26216 wxTimeSpan result;
26217 void *argp1 = 0 ;
26218 int res1 = 0 ;
26219 void *argp2 = 0 ;
26220 int res2 = 0 ;
26221 PyObject * obj0 = 0 ;
26222 PyObject * obj1 = 0 ;
26223 char * kwnames[] = {
26224 (char *) "self",(char *) "dt", NULL
26225 };
26226
26227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26229 if (!SWIG_IsOK(res1)) {
26230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26231 }
26232 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26233 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26234 if (!SWIG_IsOK(res2)) {
26235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26236 }
26237 if (!argp2) {
26238 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26239 }
26240 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26241 {
26242 PyThreadState* __tstate = wxPyBeginAllowThreads();
26243 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26244 wxPyEndAllowThreads(__tstate);
26245 if (PyErr_Occurred()) SWIG_fail;
26246 }
26247 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26255 PyObject *resultobj = 0;
26256 wxDateTime *arg1 = (wxDateTime *) 0 ;
26257 wxTimeSpan *arg2 = 0 ;
26258 wxDateTime *result = 0 ;
26259 void *argp1 = 0 ;
26260 int res1 = 0 ;
26261 void *argp2 = 0 ;
26262 int res2 = 0 ;
26263
26264 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26266 if (!SWIG_IsOK(res1)) {
26267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26268 }
26269 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26270 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26271 if (!SWIG_IsOK(res2)) {
26272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26273 }
26274 if (!argp2) {
26275 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26276 }
26277 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26278 {
26279 PyThreadState* __tstate = wxPyBeginAllowThreads();
26280 {
26281 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26282 result = (wxDateTime *) &_result_ref;
26283 }
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26288 return resultobj;
26289 fail:
26290 return NULL;
26291 }
26292
26293
26294 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26295 PyObject *resultobj = 0;
26296 wxDateTime *arg1 = (wxDateTime *) 0 ;
26297 wxDateSpan *arg2 = 0 ;
26298 wxDateTime *result = 0 ;
26299 void *argp1 = 0 ;
26300 int res1 = 0 ;
26301 void *argp2 = 0 ;
26302 int res2 = 0 ;
26303
26304 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26306 if (!SWIG_IsOK(res1)) {
26307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26308 }
26309 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26310 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26311 if (!SWIG_IsOK(res2)) {
26312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26313 }
26314 if (!argp2) {
26315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26316 }
26317 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26318 {
26319 PyThreadState* __tstate = wxPyBeginAllowThreads();
26320 {
26321 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26322 result = (wxDateTime *) &_result_ref;
26323 }
26324 wxPyEndAllowThreads(__tstate);
26325 if (PyErr_Occurred()) SWIG_fail;
26326 }
26327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26328 return resultobj;
26329 fail:
26330 return NULL;
26331 }
26332
26333
26334 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26335 int argc;
26336 PyObject *argv[3];
26337
26338 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26339 --argc;
26340 if (argc == 2) {
26341 int _v = 0;
26342 {
26343 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26344 _v = SWIG_CheckState(res);
26345 }
26346 if (!_v) goto check_1;
26347 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26348 }
26349 check_1:
26350
26351 if (argc == 2) {
26352 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26353 }
26354
26355 fail:
26356 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26357 return NULL;
26358 }
26359
26360
26361 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26362 PyObject *resultobj = 0;
26363 wxDateTime *arg1 = (wxDateTime *) 0 ;
26364 wxTimeSpan *arg2 = 0 ;
26365 wxDateTime *result = 0 ;
26366 void *argp1 = 0 ;
26367 int res1 = 0 ;
26368 void *argp2 = 0 ;
26369 int res2 = 0 ;
26370
26371 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26375 }
26376 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26377 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26378 if (!SWIG_IsOK(res2)) {
26379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26380 }
26381 if (!argp2) {
26382 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26383 }
26384 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26385 {
26386 PyThreadState* __tstate = wxPyBeginAllowThreads();
26387 {
26388 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26389 result = (wxDateTime *) &_result_ref;
26390 }
26391 wxPyEndAllowThreads(__tstate);
26392 if (PyErr_Occurred()) SWIG_fail;
26393 }
26394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26395 return resultobj;
26396 fail:
26397 return NULL;
26398 }
26399
26400
26401 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26402 PyObject *resultobj = 0;
26403 wxDateTime *arg1 = (wxDateTime *) 0 ;
26404 wxDateSpan *arg2 = 0 ;
26405 wxDateTime *result = 0 ;
26406 void *argp1 = 0 ;
26407 int res1 = 0 ;
26408 void *argp2 = 0 ;
26409 int res2 = 0 ;
26410
26411 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26413 if (!SWIG_IsOK(res1)) {
26414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26415 }
26416 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26417 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26418 if (!SWIG_IsOK(res2)) {
26419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26420 }
26421 if (!argp2) {
26422 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26423 }
26424 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 {
26428 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26429 result = (wxDateTime *) &_result_ref;
26430 }
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26442 int argc;
26443 PyObject *argv[3];
26444
26445 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26446 --argc;
26447 if (argc == 2) {
26448 int _v = 0;
26449 {
26450 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26451 _v = SWIG_CheckState(res);
26452 }
26453 if (!_v) goto check_1;
26454 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26455 }
26456 check_1:
26457
26458 if (argc == 2) {
26459 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26460 }
26461
26462 fail:
26463 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26464 return NULL;
26465 }
26466
26467
26468 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26469 PyObject *resultobj = 0;
26470 wxDateTime *arg1 = (wxDateTime *) 0 ;
26471 wxTimeSpan *arg2 = 0 ;
26472 wxDateTime result;
26473 void *argp1 = 0 ;
26474 int res1 = 0 ;
26475 void *argp2 = 0 ;
26476 int res2 = 0 ;
26477
26478 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26480 if (!SWIG_IsOK(res1)) {
26481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26482 }
26483 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26484 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26485 if (!SWIG_IsOK(res2)) {
26486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26487 }
26488 if (!argp2) {
26489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26490 }
26491 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26506 PyObject *resultobj = 0;
26507 wxDateTime *arg1 = (wxDateTime *) 0 ;
26508 wxDateSpan *arg2 = 0 ;
26509 wxDateTime result;
26510 void *argp1 = 0 ;
26511 int res1 = 0 ;
26512 void *argp2 = 0 ;
26513 int res2 = 0 ;
26514
26515 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26517 if (!SWIG_IsOK(res1)) {
26518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26519 }
26520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26521 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26522 if (!SWIG_IsOK(res2)) {
26523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26524 }
26525 if (!argp2) {
26526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26527 }
26528 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26529 {
26530 PyThreadState* __tstate = wxPyBeginAllowThreads();
26531 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26532 wxPyEndAllowThreads(__tstate);
26533 if (PyErr_Occurred()) SWIG_fail;
26534 }
26535 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26536 return resultobj;
26537 fail:
26538 return NULL;
26539 }
26540
26541
26542 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26543 int argc;
26544 PyObject *argv[3];
26545
26546 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26547 --argc;
26548 if (argc == 2) {
26549 int _v = 0;
26550 {
26551 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26552 _v = SWIG_CheckState(res);
26553 }
26554 if (!_v) goto check_1;
26555 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26556 }
26557 check_1:
26558
26559 if (argc == 2) {
26560 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26561 }
26562
26563 fail:
26564 Py_INCREF(Py_NotImplemented);
26565 return Py_NotImplemented;
26566 }
26567
26568
26569 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26570 PyObject *resultobj = 0;
26571 wxDateTime *arg1 = (wxDateTime *) 0 ;
26572 wxDateTime *arg2 = 0 ;
26573 wxTimeSpan result;
26574 void *argp1 = 0 ;
26575 int res1 = 0 ;
26576 void *argp2 = 0 ;
26577 int res2 = 0 ;
26578
26579 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26581 if (!SWIG_IsOK(res1)) {
26582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26583 }
26584 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26585 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26586 if (!SWIG_IsOK(res2)) {
26587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26588 }
26589 if (!argp2) {
26590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26591 }
26592 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26596 wxPyEndAllowThreads(__tstate);
26597 if (PyErr_Occurred()) SWIG_fail;
26598 }
26599 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26600 return resultobj;
26601 fail:
26602 return NULL;
26603 }
26604
26605
26606 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26607 PyObject *resultobj = 0;
26608 wxDateTime *arg1 = (wxDateTime *) 0 ;
26609 wxTimeSpan *arg2 = 0 ;
26610 wxDateTime result;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 void *argp2 = 0 ;
26614 int res2 = 0 ;
26615
26616 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26618 if (!SWIG_IsOK(res1)) {
26619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26620 }
26621 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26622 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26623 if (!SWIG_IsOK(res2)) {
26624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26625 }
26626 if (!argp2) {
26627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26628 }
26629 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26630 {
26631 PyThreadState* __tstate = wxPyBeginAllowThreads();
26632 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26633 wxPyEndAllowThreads(__tstate);
26634 if (PyErr_Occurred()) SWIG_fail;
26635 }
26636 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26637 return resultobj;
26638 fail:
26639 return NULL;
26640 }
26641
26642
26643 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26644 PyObject *resultobj = 0;
26645 wxDateTime *arg1 = (wxDateTime *) 0 ;
26646 wxDateSpan *arg2 = 0 ;
26647 wxDateTime result;
26648 void *argp1 = 0 ;
26649 int res1 = 0 ;
26650 void *argp2 = 0 ;
26651 int res2 = 0 ;
26652
26653 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26655 if (!SWIG_IsOK(res1)) {
26656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26657 }
26658 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26659 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26660 if (!SWIG_IsOK(res2)) {
26661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26662 }
26663 if (!argp2) {
26664 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26665 }
26666 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26667 {
26668 PyThreadState* __tstate = wxPyBeginAllowThreads();
26669 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26670 wxPyEndAllowThreads(__tstate);
26671 if (PyErr_Occurred()) SWIG_fail;
26672 }
26673 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26681 int argc;
26682 PyObject *argv[3];
26683
26684 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26685 --argc;
26686 if (argc == 2) {
26687 int _v = 0;
26688 {
26689 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26690 _v = SWIG_CheckState(res);
26691 }
26692 if (!_v) goto check_1;
26693 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26694 }
26695 check_1:
26696
26697 if (argc == 2) {
26698 int _v = 0;
26699 {
26700 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26701 _v = SWIG_CheckState(res);
26702 }
26703 if (!_v) goto check_2;
26704 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26705 }
26706 check_2:
26707
26708 if (argc == 2) {
26709 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26710 }
26711
26712 fail:
26713 Py_INCREF(Py_NotImplemented);
26714 return Py_NotImplemented;
26715 }
26716
26717
26718 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26719 PyObject *resultobj = 0;
26720 wxDateTime *arg1 = (wxDateTime *) 0 ;
26721 wxDateTime *arg2 = (wxDateTime *) 0 ;
26722 bool result;
26723 void *argp1 = 0 ;
26724 int res1 = 0 ;
26725 void *argp2 = 0 ;
26726 int res2 = 0 ;
26727 PyObject * obj0 = 0 ;
26728 PyObject * obj1 = 0 ;
26729 char * kwnames[] = {
26730 (char *) "self",(char *) "other", NULL
26731 };
26732
26733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26735 if (!SWIG_IsOK(res1)) {
26736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26737 }
26738 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26740 if (!SWIG_IsOK(res2)) {
26741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26742 }
26743 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26744 {
26745 PyThreadState* __tstate = wxPyBeginAllowThreads();
26746 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26747 wxPyEndAllowThreads(__tstate);
26748 if (PyErr_Occurred()) SWIG_fail;
26749 }
26750 {
26751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26752 }
26753 return resultobj;
26754 fail:
26755 return NULL;
26756 }
26757
26758
26759 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26760 PyObject *resultobj = 0;
26761 wxDateTime *arg1 = (wxDateTime *) 0 ;
26762 wxDateTime *arg2 = (wxDateTime *) 0 ;
26763 bool result;
26764 void *argp1 = 0 ;
26765 int res1 = 0 ;
26766 void *argp2 = 0 ;
26767 int res2 = 0 ;
26768 PyObject * obj0 = 0 ;
26769 PyObject * obj1 = 0 ;
26770 char * kwnames[] = {
26771 (char *) "self",(char *) "other", NULL
26772 };
26773
26774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26776 if (!SWIG_IsOK(res1)) {
26777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26778 }
26779 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26781 if (!SWIG_IsOK(res2)) {
26782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26783 }
26784 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 {
26792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26793 }
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj = 0;
26802 wxDateTime *arg1 = (wxDateTime *) 0 ;
26803 wxDateTime *arg2 = (wxDateTime *) 0 ;
26804 bool result;
26805 void *argp1 = 0 ;
26806 int res1 = 0 ;
26807 void *argp2 = 0 ;
26808 int res2 = 0 ;
26809 PyObject * obj0 = 0 ;
26810 PyObject * obj1 = 0 ;
26811 char * kwnames[] = {
26812 (char *) "self",(char *) "other", NULL
26813 };
26814
26815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26817 if (!SWIG_IsOK(res1)) {
26818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26819 }
26820 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26822 if (!SWIG_IsOK(res2)) {
26823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26824 }
26825 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26829 wxPyEndAllowThreads(__tstate);
26830 if (PyErr_Occurred()) SWIG_fail;
26831 }
26832 {
26833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26834 }
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26842 PyObject *resultobj = 0;
26843 wxDateTime *arg1 = (wxDateTime *) 0 ;
26844 wxDateTime *arg2 = (wxDateTime *) 0 ;
26845 bool result;
26846 void *argp1 = 0 ;
26847 int res1 = 0 ;
26848 void *argp2 = 0 ;
26849 int res2 = 0 ;
26850 PyObject * obj0 = 0 ;
26851 PyObject * obj1 = 0 ;
26852 char * kwnames[] = {
26853 (char *) "self",(char *) "other", NULL
26854 };
26855
26856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26858 if (!SWIG_IsOK(res1)) {
26859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26860 }
26861 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26863 if (!SWIG_IsOK(res2)) {
26864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26865 }
26866 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26867 {
26868 PyThreadState* __tstate = wxPyBeginAllowThreads();
26869 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26870 wxPyEndAllowThreads(__tstate);
26871 if (PyErr_Occurred()) SWIG_fail;
26872 }
26873 {
26874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26875 }
26876 return resultobj;
26877 fail:
26878 return NULL;
26879 }
26880
26881
26882 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26883 PyObject *resultobj = 0;
26884 wxDateTime *arg1 = (wxDateTime *) 0 ;
26885 wxDateTime *arg2 = (wxDateTime *) 0 ;
26886 bool result;
26887 void *argp1 = 0 ;
26888 int res1 = 0 ;
26889 void *argp2 = 0 ;
26890 int res2 = 0 ;
26891 PyObject * obj0 = 0 ;
26892 PyObject * obj1 = 0 ;
26893 char * kwnames[] = {
26894 (char *) "self",(char *) "other", NULL
26895 };
26896
26897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26899 if (!SWIG_IsOK(res1)) {
26900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26901 }
26902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26903 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26904 if (!SWIG_IsOK(res2)) {
26905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26906 }
26907 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26908 {
26909 PyThreadState* __tstate = wxPyBeginAllowThreads();
26910 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26911 wxPyEndAllowThreads(__tstate);
26912 if (PyErr_Occurred()) SWIG_fail;
26913 }
26914 {
26915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26916 }
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26924 PyObject *resultobj = 0;
26925 wxDateTime *arg1 = (wxDateTime *) 0 ;
26926 wxDateTime *arg2 = (wxDateTime *) 0 ;
26927 bool result;
26928 void *argp1 = 0 ;
26929 int res1 = 0 ;
26930 void *argp2 = 0 ;
26931 int res2 = 0 ;
26932 PyObject * obj0 = 0 ;
26933 PyObject * obj1 = 0 ;
26934 char * kwnames[] = {
26935 (char *) "self",(char *) "other", NULL
26936 };
26937
26938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26940 if (!SWIG_IsOK(res1)) {
26941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26942 }
26943 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26945 if (!SWIG_IsOK(res2)) {
26946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26947 }
26948 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 {
26956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26957 }
26958 return resultobj;
26959 fail:
26960 return NULL;
26961 }
26962
26963
26964 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26965 PyObject *resultobj = 0;
26966 wxDateTime *arg1 = (wxDateTime *) 0 ;
26967 wxString *arg2 = 0 ;
26968 int result;
26969 void *argp1 = 0 ;
26970 int res1 = 0 ;
26971 bool temp2 = false ;
26972 PyObject * obj0 = 0 ;
26973 PyObject * obj1 = 0 ;
26974 char * kwnames[] = {
26975 (char *) "self",(char *) "date", NULL
26976 };
26977
26978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26980 if (!SWIG_IsOK(res1)) {
26981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26982 }
26983 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26984 {
26985 arg2 = wxString_in_helper(obj1);
26986 if (arg2 == NULL) SWIG_fail;
26987 temp2 = true;
26988 }
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 resultobj = SWIG_From_int(static_cast< int >(result));
26996 {
26997 if (temp2)
26998 delete arg2;
26999 }
27000 return resultobj;
27001 fail:
27002 {
27003 if (temp2)
27004 delete arg2;
27005 }
27006 return NULL;
27007 }
27008
27009
27010 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27011 PyObject *resultobj = 0;
27012 wxDateTime *arg1 = (wxDateTime *) 0 ;
27013 wxString *arg2 = 0 ;
27014 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27015 wxString *arg3 = (wxString *) &arg3_defvalue ;
27016 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27017 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27018 int result;
27019 void *argp1 = 0 ;
27020 int res1 = 0 ;
27021 bool temp2 = false ;
27022 bool temp3 = false ;
27023 void *argp4 = 0 ;
27024 int res4 = 0 ;
27025 PyObject * obj0 = 0 ;
27026 PyObject * obj1 = 0 ;
27027 PyObject * obj2 = 0 ;
27028 PyObject * obj3 = 0 ;
27029 char * kwnames[] = {
27030 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27031 };
27032
27033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27035 if (!SWIG_IsOK(res1)) {
27036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27037 }
27038 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27039 {
27040 arg2 = wxString_in_helper(obj1);
27041 if (arg2 == NULL) SWIG_fail;
27042 temp2 = true;
27043 }
27044 if (obj2) {
27045 {
27046 arg3 = wxString_in_helper(obj2);
27047 if (arg3 == NULL) SWIG_fail;
27048 temp3 = true;
27049 }
27050 }
27051 if (obj3) {
27052 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
27053 if (!SWIG_IsOK(res4)) {
27054 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27055 }
27056 if (!argp4) {
27057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27058 }
27059 arg4 = reinterpret_cast< wxDateTime * >(argp4);
27060 }
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 resultobj = SWIG_From_int(static_cast< int >(result));
27068 {
27069 if (temp2)
27070 delete arg2;
27071 }
27072 {
27073 if (temp3)
27074 delete arg3;
27075 }
27076 return resultobj;
27077 fail:
27078 {
27079 if (temp2)
27080 delete arg2;
27081 }
27082 {
27083 if (temp3)
27084 delete arg3;
27085 }
27086 return NULL;
27087 }
27088
27089
27090 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj = 0;
27092 wxDateTime *arg1 = (wxDateTime *) 0 ;
27093 wxString *arg2 = 0 ;
27094 int result;
27095 void *argp1 = 0 ;
27096 int res1 = 0 ;
27097 bool temp2 = false ;
27098 PyObject * obj0 = 0 ;
27099 PyObject * obj1 = 0 ;
27100 char * kwnames[] = {
27101 (char *) "self",(char *) "datetime", NULL
27102 };
27103
27104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
27105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27106 if (!SWIG_IsOK(res1)) {
27107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27108 }
27109 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27110 {
27111 arg2 = wxString_in_helper(obj1);
27112 if (arg2 == NULL) SWIG_fail;
27113 temp2 = true;
27114 }
27115 {
27116 PyThreadState* __tstate = wxPyBeginAllowThreads();
27117 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 resultobj = SWIG_From_int(static_cast< int >(result));
27122 {
27123 if (temp2)
27124 delete arg2;
27125 }
27126 return resultobj;
27127 fail:
27128 {
27129 if (temp2)
27130 delete arg2;
27131 }
27132 return NULL;
27133 }
27134
27135
27136 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj = 0;
27138 wxDateTime *arg1 = (wxDateTime *) 0 ;
27139 wxString *arg2 = 0 ;
27140 int result;
27141 void *argp1 = 0 ;
27142 int res1 = 0 ;
27143 bool temp2 = false ;
27144 PyObject * obj0 = 0 ;
27145 PyObject * obj1 = 0 ;
27146 char * kwnames[] = {
27147 (char *) "self",(char *) "date", NULL
27148 };
27149
27150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27152 if (!SWIG_IsOK(res1)) {
27153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27154 }
27155 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27156 {
27157 arg2 = wxString_in_helper(obj1);
27158 if (arg2 == NULL) SWIG_fail;
27159 temp2 = true;
27160 }
27161 {
27162 PyThreadState* __tstate = wxPyBeginAllowThreads();
27163 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 resultobj = SWIG_From_int(static_cast< int >(result));
27168 {
27169 if (temp2)
27170 delete arg2;
27171 }
27172 return resultobj;
27173 fail:
27174 {
27175 if (temp2)
27176 delete arg2;
27177 }
27178 return NULL;
27179 }
27180
27181
27182 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27183 PyObject *resultobj = 0;
27184 wxDateTime *arg1 = (wxDateTime *) 0 ;
27185 wxString *arg2 = 0 ;
27186 int result;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 bool temp2 = false ;
27190 PyObject * obj0 = 0 ;
27191 PyObject * obj1 = 0 ;
27192 char * kwnames[] = {
27193 (char *) "self",(char *) "time", NULL
27194 };
27195
27196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27198 if (!SWIG_IsOK(res1)) {
27199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27200 }
27201 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27202 {
27203 arg2 = wxString_in_helper(obj1);
27204 if (arg2 == NULL) SWIG_fail;
27205 temp2 = true;
27206 }
27207 {
27208 PyThreadState* __tstate = wxPyBeginAllowThreads();
27209 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27210 wxPyEndAllowThreads(__tstate);
27211 if (PyErr_Occurred()) SWIG_fail;
27212 }
27213 resultobj = SWIG_From_int(static_cast< int >(result));
27214 {
27215 if (temp2)
27216 delete arg2;
27217 }
27218 return resultobj;
27219 fail:
27220 {
27221 if (temp2)
27222 delete arg2;
27223 }
27224 return NULL;
27225 }
27226
27227
27228 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27229 PyObject *resultobj = 0;
27230 wxDateTime *arg1 = (wxDateTime *) 0 ;
27231 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27232 wxString *arg2 = (wxString *) &arg2_defvalue ;
27233 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27234 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27235 wxString result;
27236 void *argp1 = 0 ;
27237 int res1 = 0 ;
27238 bool temp2 = false ;
27239 bool temp3 = false ;
27240 PyObject * obj0 = 0 ;
27241 PyObject * obj1 = 0 ;
27242 PyObject * obj2 = 0 ;
27243 char * kwnames[] = {
27244 (char *) "self",(char *) "format",(char *) "tz", NULL
27245 };
27246
27247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27249 if (!SWIG_IsOK(res1)) {
27250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27251 }
27252 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27253 if (obj1) {
27254 {
27255 arg2 = wxString_in_helper(obj1);
27256 if (arg2 == NULL) SWIG_fail;
27257 temp2 = true;
27258 }
27259 }
27260 if (obj2) {
27261 {
27262 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27263 temp3 = true;
27264 }
27265 }
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 #if wxUSE_UNICODE
27274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27275 #else
27276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27277 #endif
27278 }
27279 {
27280 if (temp2)
27281 delete arg2;
27282 }
27283 {
27284 if (temp3) delete arg3;
27285 }
27286 return resultobj;
27287 fail:
27288 {
27289 if (temp2)
27290 delete arg2;
27291 }
27292 {
27293 if (temp3) delete arg3;
27294 }
27295 return NULL;
27296 }
27297
27298
27299 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27300 PyObject *resultobj = 0;
27301 wxDateTime *arg1 = (wxDateTime *) 0 ;
27302 wxString result;
27303 void *argp1 = 0 ;
27304 int res1 = 0 ;
27305 PyObject *swig_obj[1] ;
27306
27307 if (!args) SWIG_fail;
27308 swig_obj[0] = args;
27309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27310 if (!SWIG_IsOK(res1)) {
27311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27312 }
27313 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27314 {
27315 PyThreadState* __tstate = wxPyBeginAllowThreads();
27316 result = ((wxDateTime const *)arg1)->FormatDate();
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 {
27321 #if wxUSE_UNICODE
27322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27323 #else
27324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27325 #endif
27326 }
27327 return resultobj;
27328 fail:
27329 return NULL;
27330 }
27331
27332
27333 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27334 PyObject *resultobj = 0;
27335 wxDateTime *arg1 = (wxDateTime *) 0 ;
27336 wxString result;
27337 void *argp1 = 0 ;
27338 int res1 = 0 ;
27339 PyObject *swig_obj[1] ;
27340
27341 if (!args) SWIG_fail;
27342 swig_obj[0] = args;
27343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27344 if (!SWIG_IsOK(res1)) {
27345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27346 }
27347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27348 {
27349 PyThreadState* __tstate = wxPyBeginAllowThreads();
27350 result = ((wxDateTime const *)arg1)->FormatTime();
27351 wxPyEndAllowThreads(__tstate);
27352 if (PyErr_Occurred()) SWIG_fail;
27353 }
27354 {
27355 #if wxUSE_UNICODE
27356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27357 #else
27358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27359 #endif
27360 }
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27368 PyObject *resultobj = 0;
27369 wxDateTime *arg1 = (wxDateTime *) 0 ;
27370 wxString result;
27371 void *argp1 = 0 ;
27372 int res1 = 0 ;
27373 PyObject *swig_obj[1] ;
27374
27375 if (!args) SWIG_fail;
27376 swig_obj[0] = args;
27377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27378 if (!SWIG_IsOK(res1)) {
27379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27380 }
27381 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27382 {
27383 PyThreadState* __tstate = wxPyBeginAllowThreads();
27384 result = ((wxDateTime const *)arg1)->FormatISODate();
27385 wxPyEndAllowThreads(__tstate);
27386 if (PyErr_Occurred()) SWIG_fail;
27387 }
27388 {
27389 #if wxUSE_UNICODE
27390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27391 #else
27392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27393 #endif
27394 }
27395 return resultobj;
27396 fail:
27397 return NULL;
27398 }
27399
27400
27401 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27402 PyObject *resultobj = 0;
27403 wxDateTime *arg1 = (wxDateTime *) 0 ;
27404 wxString result;
27405 void *argp1 = 0 ;
27406 int res1 = 0 ;
27407 PyObject *swig_obj[1] ;
27408
27409 if (!args) SWIG_fail;
27410 swig_obj[0] = args;
27411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27412 if (!SWIG_IsOK(res1)) {
27413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27414 }
27415 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = ((wxDateTime const *)arg1)->FormatISOTime();
27419 wxPyEndAllowThreads(__tstate);
27420 if (PyErr_Occurred()) SWIG_fail;
27421 }
27422 {
27423 #if wxUSE_UNICODE
27424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27425 #else
27426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27427 #endif
27428 }
27429 return resultobj;
27430 fail:
27431 return NULL;
27432 }
27433
27434
27435 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27436 PyObject *obj;
27437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27438 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27439 return SWIG_Py_Void();
27440 }
27441
27442 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27443 return SWIG_Python_InitShadowInstance(args);
27444 }
27445
27446 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj = 0;
27448 long arg1 ;
27449 wxTimeSpan result;
27450 long val1 ;
27451 int ecode1 = 0 ;
27452 PyObject * obj0 = 0 ;
27453 char * kwnames[] = {
27454 (char *) "ms", NULL
27455 };
27456
27457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27458 ecode1 = SWIG_AsVal_long(obj0, &val1);
27459 if (!SWIG_IsOK(ecode1)) {
27460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27461 }
27462 arg1 = static_cast< long >(val1);
27463 {
27464 PyThreadState* __tstate = wxPyBeginAllowThreads();
27465 result = wxTimeSpan::Milliseconds(arg1);
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27477 PyObject *resultobj = 0;
27478 wxTimeSpan result;
27479
27480 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27481 {
27482 PyThreadState* __tstate = wxPyBeginAllowThreads();
27483 result = wxTimeSpan::Millisecond();
27484 wxPyEndAllowThreads(__tstate);
27485 if (PyErr_Occurred()) SWIG_fail;
27486 }
27487 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27495 PyObject *resultobj = 0;
27496 long arg1 ;
27497 wxTimeSpan result;
27498 long val1 ;
27499 int ecode1 = 0 ;
27500 PyObject * obj0 = 0 ;
27501 char * kwnames[] = {
27502 (char *) "sec", NULL
27503 };
27504
27505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27506 ecode1 = SWIG_AsVal_long(obj0, &val1);
27507 if (!SWIG_IsOK(ecode1)) {
27508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27509 }
27510 arg1 = static_cast< long >(val1);
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 result = wxTimeSpan::Seconds(arg1);
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27525 PyObject *resultobj = 0;
27526 wxTimeSpan result;
27527
27528 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = wxTimeSpan::Second();
27532 wxPyEndAllowThreads(__tstate);
27533 if (PyErr_Occurred()) SWIG_fail;
27534 }
27535 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27543 PyObject *resultobj = 0;
27544 long arg1 ;
27545 wxTimeSpan result;
27546 long val1 ;
27547 int ecode1 = 0 ;
27548 PyObject * obj0 = 0 ;
27549 char * kwnames[] = {
27550 (char *) "min", NULL
27551 };
27552
27553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27554 ecode1 = SWIG_AsVal_long(obj0, &val1);
27555 if (!SWIG_IsOK(ecode1)) {
27556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27557 }
27558 arg1 = static_cast< long >(val1);
27559 {
27560 PyThreadState* __tstate = wxPyBeginAllowThreads();
27561 result = wxTimeSpan::Minutes(arg1);
27562 wxPyEndAllowThreads(__tstate);
27563 if (PyErr_Occurred()) SWIG_fail;
27564 }
27565 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27566 return resultobj;
27567 fail:
27568 return NULL;
27569 }
27570
27571
27572 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27573 PyObject *resultobj = 0;
27574 wxTimeSpan result;
27575
27576 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 result = wxTimeSpan::Minute();
27580 wxPyEndAllowThreads(__tstate);
27581 if (PyErr_Occurred()) SWIG_fail;
27582 }
27583 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27584 return resultobj;
27585 fail:
27586 return NULL;
27587 }
27588
27589
27590 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27591 PyObject *resultobj = 0;
27592 long arg1 ;
27593 wxTimeSpan result;
27594 long val1 ;
27595 int ecode1 = 0 ;
27596 PyObject * obj0 = 0 ;
27597 char * kwnames[] = {
27598 (char *) "hours", NULL
27599 };
27600
27601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27602 ecode1 = SWIG_AsVal_long(obj0, &val1);
27603 if (!SWIG_IsOK(ecode1)) {
27604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27605 }
27606 arg1 = static_cast< long >(val1);
27607 {
27608 PyThreadState* __tstate = wxPyBeginAllowThreads();
27609 result = wxTimeSpan::Hours(arg1);
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27614 return resultobj;
27615 fail:
27616 return NULL;
27617 }
27618
27619
27620 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27621 PyObject *resultobj = 0;
27622 wxTimeSpan result;
27623
27624 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27625 {
27626 PyThreadState* __tstate = wxPyBeginAllowThreads();
27627 result = wxTimeSpan::Hour();
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27639 PyObject *resultobj = 0;
27640 long arg1 ;
27641 wxTimeSpan result;
27642 long val1 ;
27643 int ecode1 = 0 ;
27644 PyObject * obj0 = 0 ;
27645 char * kwnames[] = {
27646 (char *) "days", NULL
27647 };
27648
27649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27650 ecode1 = SWIG_AsVal_long(obj0, &val1);
27651 if (!SWIG_IsOK(ecode1)) {
27652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27653 }
27654 arg1 = static_cast< long >(val1);
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 result = wxTimeSpan::Days(arg1);
27658 wxPyEndAllowThreads(__tstate);
27659 if (PyErr_Occurred()) SWIG_fail;
27660 }
27661 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27662 return resultobj;
27663 fail:
27664 return NULL;
27665 }
27666
27667
27668 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27669 PyObject *resultobj = 0;
27670 wxTimeSpan result;
27671
27672 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27673 {
27674 PyThreadState* __tstate = wxPyBeginAllowThreads();
27675 result = wxTimeSpan::Day();
27676 wxPyEndAllowThreads(__tstate);
27677 if (PyErr_Occurred()) SWIG_fail;
27678 }
27679 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27680 return resultobj;
27681 fail:
27682 return NULL;
27683 }
27684
27685
27686 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27687 PyObject *resultobj = 0;
27688 long arg1 ;
27689 wxTimeSpan result;
27690 long val1 ;
27691 int ecode1 = 0 ;
27692 PyObject * obj0 = 0 ;
27693 char * kwnames[] = {
27694 (char *) "days", NULL
27695 };
27696
27697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27698 ecode1 = SWIG_AsVal_long(obj0, &val1);
27699 if (!SWIG_IsOK(ecode1)) {
27700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27701 }
27702 arg1 = static_cast< long >(val1);
27703 {
27704 PyThreadState* __tstate = wxPyBeginAllowThreads();
27705 result = wxTimeSpan::Weeks(arg1);
27706 wxPyEndAllowThreads(__tstate);
27707 if (PyErr_Occurred()) SWIG_fail;
27708 }
27709 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27710 return resultobj;
27711 fail:
27712 return NULL;
27713 }
27714
27715
27716 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27717 PyObject *resultobj = 0;
27718 wxTimeSpan result;
27719
27720 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27721 {
27722 PyThreadState* __tstate = wxPyBeginAllowThreads();
27723 result = wxTimeSpan::Week();
27724 wxPyEndAllowThreads(__tstate);
27725 if (PyErr_Occurred()) SWIG_fail;
27726 }
27727 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27728 return resultobj;
27729 fail:
27730 return NULL;
27731 }
27732
27733
27734 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27735 PyObject *resultobj = 0;
27736 long arg1 = (long) 0 ;
27737 long arg2 = (long) 0 ;
27738 long arg3 = (long) 0 ;
27739 long arg4 = (long) 0 ;
27740 wxTimeSpan *result = 0 ;
27741 long val1 ;
27742 int ecode1 = 0 ;
27743 long val2 ;
27744 int ecode2 = 0 ;
27745 long val3 ;
27746 int ecode3 = 0 ;
27747 long val4 ;
27748 int ecode4 = 0 ;
27749 PyObject * obj0 = 0 ;
27750 PyObject * obj1 = 0 ;
27751 PyObject * obj2 = 0 ;
27752 PyObject * obj3 = 0 ;
27753 char * kwnames[] = {
27754 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27755 };
27756
27757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27758 if (obj0) {
27759 ecode1 = SWIG_AsVal_long(obj0, &val1);
27760 if (!SWIG_IsOK(ecode1)) {
27761 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27762 }
27763 arg1 = static_cast< long >(val1);
27764 }
27765 if (obj1) {
27766 ecode2 = SWIG_AsVal_long(obj1, &val2);
27767 if (!SWIG_IsOK(ecode2)) {
27768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27769 }
27770 arg2 = static_cast< long >(val2);
27771 }
27772 if (obj2) {
27773 ecode3 = SWIG_AsVal_long(obj2, &val3);
27774 if (!SWIG_IsOK(ecode3)) {
27775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27776 }
27777 arg3 = static_cast< long >(val3);
27778 }
27779 if (obj3) {
27780 ecode4 = SWIG_AsVal_long(obj3, &val4);
27781 if (!SWIG_IsOK(ecode4)) {
27782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27783 }
27784 arg4 = static_cast< long >(val4);
27785 }
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27800 PyObject *resultobj = 0;
27801 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27802 void *argp1 = 0 ;
27803 int res1 = 0 ;
27804 PyObject *swig_obj[1] ;
27805
27806 if (!args) SWIG_fail;
27807 swig_obj[0] = args;
27808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27809 if (!SWIG_IsOK(res1)) {
27810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27811 }
27812 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 delete arg1;
27816
27817 wxPyEndAllowThreads(__tstate);
27818 if (PyErr_Occurred()) SWIG_fail;
27819 }
27820 resultobj = SWIG_Py_Void();
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27828 PyObject *resultobj = 0;
27829 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27830 wxTimeSpan *arg2 = 0 ;
27831 wxTimeSpan *result = 0 ;
27832 void *argp1 = 0 ;
27833 int res1 = 0 ;
27834 void *argp2 = 0 ;
27835 int res2 = 0 ;
27836 PyObject * obj0 = 0 ;
27837 PyObject * obj1 = 0 ;
27838 char * kwnames[] = {
27839 (char *) "self",(char *) "diff", NULL
27840 };
27841
27842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27846 }
27847 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27848 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27849 if (!SWIG_IsOK(res2)) {
27850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27851 }
27852 if (!argp2) {
27853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27854 }
27855 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27856 {
27857 PyThreadState* __tstate = wxPyBeginAllowThreads();
27858 {
27859 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27860 result = (wxTimeSpan *) &_result_ref;
27861 }
27862 wxPyEndAllowThreads(__tstate);
27863 if (PyErr_Occurred()) SWIG_fail;
27864 }
27865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27866 return resultobj;
27867 fail:
27868 return NULL;
27869 }
27870
27871
27872 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27873 PyObject *resultobj = 0;
27874 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27875 wxTimeSpan *arg2 = 0 ;
27876 wxTimeSpan *result = 0 ;
27877 void *argp1 = 0 ;
27878 int res1 = 0 ;
27879 void *argp2 = 0 ;
27880 int res2 = 0 ;
27881 PyObject * obj0 = 0 ;
27882 PyObject * obj1 = 0 ;
27883 char * kwnames[] = {
27884 (char *) "self",(char *) "diff", NULL
27885 };
27886
27887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27889 if (!SWIG_IsOK(res1)) {
27890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27891 }
27892 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27894 if (!SWIG_IsOK(res2)) {
27895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27896 }
27897 if (!argp2) {
27898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27899 }
27900 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 {
27904 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27905 result = (wxTimeSpan *) &_result_ref;
27906 }
27907 wxPyEndAllowThreads(__tstate);
27908 if (PyErr_Occurred()) SWIG_fail;
27909 }
27910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27918 PyObject *resultobj = 0;
27919 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27920 int arg2 ;
27921 wxTimeSpan *result = 0 ;
27922 void *argp1 = 0 ;
27923 int res1 = 0 ;
27924 int val2 ;
27925 int ecode2 = 0 ;
27926 PyObject * obj0 = 0 ;
27927 PyObject * obj1 = 0 ;
27928 char * kwnames[] = {
27929 (char *) "self",(char *) "n", NULL
27930 };
27931
27932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27934 if (!SWIG_IsOK(res1)) {
27935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27936 }
27937 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27938 ecode2 = SWIG_AsVal_int(obj1, &val2);
27939 if (!SWIG_IsOK(ecode2)) {
27940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27941 }
27942 arg2 = static_cast< int >(val2);
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 {
27946 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27947 result = (wxTimeSpan *) &_result_ref;
27948 }
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27960 PyObject *resultobj = 0;
27961 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27962 wxTimeSpan *result = 0 ;
27963 void *argp1 = 0 ;
27964 int res1 = 0 ;
27965 PyObject *swig_obj[1] ;
27966
27967 if (!args) SWIG_fail;
27968 swig_obj[0] = args;
27969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27970 if (!SWIG_IsOK(res1)) {
27971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27972 }
27973 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27974 {
27975 PyThreadState* __tstate = wxPyBeginAllowThreads();
27976 {
27977 wxTimeSpan &_result_ref = (arg1)->Neg();
27978 result = (wxTimeSpan *) &_result_ref;
27979 }
27980 wxPyEndAllowThreads(__tstate);
27981 if (PyErr_Occurred()) SWIG_fail;
27982 }
27983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27984 return resultobj;
27985 fail:
27986 return NULL;
27987 }
27988
27989
27990 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27991 PyObject *resultobj = 0;
27992 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27993 wxTimeSpan result;
27994 void *argp1 = 0 ;
27995 int res1 = 0 ;
27996 PyObject *swig_obj[1] ;
27997
27998 if (!args) SWIG_fail;
27999 swig_obj[0] = args;
28000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28001 if (!SWIG_IsOK(res1)) {
28002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28003 }
28004 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = ((wxTimeSpan const *)arg1)->Abs();
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28012 return resultobj;
28013 fail:
28014 return NULL;
28015 }
28016
28017
28018 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28019 PyObject *resultobj = 0;
28020 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28021 wxTimeSpan *arg2 = 0 ;
28022 wxTimeSpan *result = 0 ;
28023 void *argp1 = 0 ;
28024 int res1 = 0 ;
28025 void *argp2 = 0 ;
28026 int res2 = 0 ;
28027 PyObject * obj0 = 0 ;
28028 PyObject * obj1 = 0 ;
28029 char * kwnames[] = {
28030 (char *) "self",(char *) "diff", NULL
28031 };
28032
28033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28035 if (!SWIG_IsOK(res1)) {
28036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28037 }
28038 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28039 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28040 if (!SWIG_IsOK(res2)) {
28041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28042 }
28043 if (!argp2) {
28044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28045 }
28046 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28047 {
28048 PyThreadState* __tstate = wxPyBeginAllowThreads();
28049 {
28050 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
28051 result = (wxTimeSpan *) &_result_ref;
28052 }
28053 wxPyEndAllowThreads(__tstate);
28054 if (PyErr_Occurred()) SWIG_fail;
28055 }
28056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28057 return resultobj;
28058 fail:
28059 return NULL;
28060 }
28061
28062
28063 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28064 PyObject *resultobj = 0;
28065 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28066 wxTimeSpan *arg2 = 0 ;
28067 wxTimeSpan *result = 0 ;
28068 void *argp1 = 0 ;
28069 int res1 = 0 ;
28070 void *argp2 = 0 ;
28071 int res2 = 0 ;
28072 PyObject * obj0 = 0 ;
28073 PyObject * obj1 = 0 ;
28074 char * kwnames[] = {
28075 (char *) "self",(char *) "diff", NULL
28076 };
28077
28078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
28079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28080 if (!SWIG_IsOK(res1)) {
28081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28082 }
28083 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28084 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28085 if (!SWIG_IsOK(res2)) {
28086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28087 }
28088 if (!argp2) {
28089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28090 }
28091 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 {
28095 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
28096 result = (wxTimeSpan *) &_result_ref;
28097 }
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28109 PyObject *resultobj = 0;
28110 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28111 int arg2 ;
28112 wxTimeSpan *result = 0 ;
28113 void *argp1 = 0 ;
28114 int res1 = 0 ;
28115 int val2 ;
28116 int ecode2 = 0 ;
28117 PyObject * obj0 = 0 ;
28118 PyObject * obj1 = 0 ;
28119 char * kwnames[] = {
28120 (char *) "self",(char *) "n", NULL
28121 };
28122
28123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28125 if (!SWIG_IsOK(res1)) {
28126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28127 }
28128 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28129 ecode2 = SWIG_AsVal_int(obj1, &val2);
28130 if (!SWIG_IsOK(ecode2)) {
28131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28132 }
28133 arg2 = static_cast< int >(val2);
28134 {
28135 PyThreadState* __tstate = wxPyBeginAllowThreads();
28136 {
28137 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28138 result = (wxTimeSpan *) &_result_ref;
28139 }
28140 wxPyEndAllowThreads(__tstate);
28141 if (PyErr_Occurred()) SWIG_fail;
28142 }
28143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28144 return resultobj;
28145 fail:
28146 return NULL;
28147 }
28148
28149
28150 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28151 PyObject *resultobj = 0;
28152 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28153 wxTimeSpan *result = 0 ;
28154 void *argp1 = 0 ;
28155 int res1 = 0 ;
28156 PyObject *swig_obj[1] ;
28157
28158 if (!args) SWIG_fail;
28159 swig_obj[0] = args;
28160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28161 if (!SWIG_IsOK(res1)) {
28162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28163 }
28164 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28165 {
28166 PyThreadState* __tstate = wxPyBeginAllowThreads();
28167 {
28168 wxTimeSpan &_result_ref = (arg1)->operator -();
28169 result = (wxTimeSpan *) &_result_ref;
28170 }
28171 wxPyEndAllowThreads(__tstate);
28172 if (PyErr_Occurred()) SWIG_fail;
28173 }
28174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28175 return resultobj;
28176 fail:
28177 return NULL;
28178 }
28179
28180
28181 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28182 PyObject *resultobj = 0;
28183 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28184 wxTimeSpan *arg2 = 0 ;
28185 wxTimeSpan result;
28186 void *argp1 = 0 ;
28187 int res1 = 0 ;
28188 void *argp2 = 0 ;
28189 int res2 = 0 ;
28190 PyObject * obj0 = 0 ;
28191 PyObject * obj1 = 0 ;
28192 char * kwnames[] = {
28193 (char *) "self",(char *) "other", NULL
28194 };
28195
28196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28198 if (!SWIG_IsOK(res1)) {
28199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28200 }
28201 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28203 if (!SWIG_IsOK(res2)) {
28204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28205 }
28206 if (!argp2) {
28207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28208 }
28209 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28210 {
28211 PyThreadState* __tstate = wxPyBeginAllowThreads();
28212 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28213 wxPyEndAllowThreads(__tstate);
28214 if (PyErr_Occurred()) SWIG_fail;
28215 }
28216 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28217 return resultobj;
28218 fail:
28219 return NULL;
28220 }
28221
28222
28223 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28224 PyObject *resultobj = 0;
28225 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28226 wxTimeSpan *arg2 = 0 ;
28227 wxTimeSpan result;
28228 void *argp1 = 0 ;
28229 int res1 = 0 ;
28230 void *argp2 = 0 ;
28231 int res2 = 0 ;
28232 PyObject * obj0 = 0 ;
28233 PyObject * obj1 = 0 ;
28234 char * kwnames[] = {
28235 (char *) "self",(char *) "other", NULL
28236 };
28237
28238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28240 if (!SWIG_IsOK(res1)) {
28241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28242 }
28243 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28245 if (!SWIG_IsOK(res2)) {
28246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28247 }
28248 if (!argp2) {
28249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28250 }
28251 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28252 {
28253 PyThreadState* __tstate = wxPyBeginAllowThreads();
28254 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28255 wxPyEndAllowThreads(__tstate);
28256 if (PyErr_Occurred()) SWIG_fail;
28257 }
28258 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28259 return resultobj;
28260 fail:
28261 return NULL;
28262 }
28263
28264
28265 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28266 PyObject *resultobj = 0;
28267 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28268 int arg2 ;
28269 wxTimeSpan result;
28270 void *argp1 = 0 ;
28271 int res1 = 0 ;
28272 int val2 ;
28273 int ecode2 = 0 ;
28274 PyObject * obj0 = 0 ;
28275 PyObject * obj1 = 0 ;
28276 char * kwnames[] = {
28277 (char *) "self",(char *) "n", NULL
28278 };
28279
28280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28282 if (!SWIG_IsOK(res1)) {
28283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28284 }
28285 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28286 ecode2 = SWIG_AsVal_int(obj1, &val2);
28287 if (!SWIG_IsOK(ecode2)) {
28288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28289 }
28290 arg2 = static_cast< int >(val2);
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = wxTimeSpan___mul__(arg1,arg2);
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28305 PyObject *resultobj = 0;
28306 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28307 int arg2 ;
28308 wxTimeSpan result;
28309 void *argp1 = 0 ;
28310 int res1 = 0 ;
28311 int val2 ;
28312 int ecode2 = 0 ;
28313 PyObject * obj0 = 0 ;
28314 PyObject * obj1 = 0 ;
28315 char * kwnames[] = {
28316 (char *) "self",(char *) "n", NULL
28317 };
28318
28319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28321 if (!SWIG_IsOK(res1)) {
28322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28323 }
28324 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28325 ecode2 = SWIG_AsVal_int(obj1, &val2);
28326 if (!SWIG_IsOK(ecode2)) {
28327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28328 }
28329 arg2 = static_cast< int >(val2);
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 result = wxTimeSpan___rmul__(arg1,arg2);
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28344 PyObject *resultobj = 0;
28345 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28346 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28347 bool result;
28348 void *argp1 = 0 ;
28349 int res1 = 0 ;
28350 void *argp2 = 0 ;
28351 int res2 = 0 ;
28352 PyObject * obj0 = 0 ;
28353 PyObject * obj1 = 0 ;
28354 char * kwnames[] = {
28355 (char *) "self",(char *) "other", NULL
28356 };
28357
28358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28360 if (!SWIG_IsOK(res1)) {
28361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28362 }
28363 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28365 if (!SWIG_IsOK(res2)) {
28366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28367 }
28368 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28369 {
28370 PyThreadState* __tstate = wxPyBeginAllowThreads();
28371 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28372 wxPyEndAllowThreads(__tstate);
28373 if (PyErr_Occurred()) SWIG_fail;
28374 }
28375 {
28376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28377 }
28378 return resultobj;
28379 fail:
28380 return NULL;
28381 }
28382
28383
28384 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28385 PyObject *resultobj = 0;
28386 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28387 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28388 bool result;
28389 void *argp1 = 0 ;
28390 int res1 = 0 ;
28391 void *argp2 = 0 ;
28392 int res2 = 0 ;
28393 PyObject * obj0 = 0 ;
28394 PyObject * obj1 = 0 ;
28395 char * kwnames[] = {
28396 (char *) "self",(char *) "other", NULL
28397 };
28398
28399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28401 if (!SWIG_IsOK(res1)) {
28402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28403 }
28404 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28406 if (!SWIG_IsOK(res2)) {
28407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28408 }
28409 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28410 {
28411 PyThreadState* __tstate = wxPyBeginAllowThreads();
28412 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28413 wxPyEndAllowThreads(__tstate);
28414 if (PyErr_Occurred()) SWIG_fail;
28415 }
28416 {
28417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28418 }
28419 return resultobj;
28420 fail:
28421 return NULL;
28422 }
28423
28424
28425 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28426 PyObject *resultobj = 0;
28427 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28428 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28429 bool result;
28430 void *argp1 = 0 ;
28431 int res1 = 0 ;
28432 void *argp2 = 0 ;
28433 int res2 = 0 ;
28434 PyObject * obj0 = 0 ;
28435 PyObject * obj1 = 0 ;
28436 char * kwnames[] = {
28437 (char *) "self",(char *) "other", NULL
28438 };
28439
28440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28442 if (!SWIG_IsOK(res1)) {
28443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28444 }
28445 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28446 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28447 if (!SWIG_IsOK(res2)) {
28448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28449 }
28450 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 {
28458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28459 }
28460 return resultobj;
28461 fail:
28462 return NULL;
28463 }
28464
28465
28466 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28467 PyObject *resultobj = 0;
28468 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28469 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28470 bool result;
28471 void *argp1 = 0 ;
28472 int res1 = 0 ;
28473 void *argp2 = 0 ;
28474 int res2 = 0 ;
28475 PyObject * obj0 = 0 ;
28476 PyObject * obj1 = 0 ;
28477 char * kwnames[] = {
28478 (char *) "self",(char *) "other", NULL
28479 };
28480
28481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28483 if (!SWIG_IsOK(res1)) {
28484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28485 }
28486 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28488 if (!SWIG_IsOK(res2)) {
28489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28490 }
28491 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28492 {
28493 PyThreadState* __tstate = wxPyBeginAllowThreads();
28494 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 {
28499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28500 }
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28508 PyObject *resultobj = 0;
28509 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28510 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28511 bool result;
28512 void *argp1 = 0 ;
28513 int res1 = 0 ;
28514 void *argp2 = 0 ;
28515 int res2 = 0 ;
28516 PyObject * obj0 = 0 ;
28517 PyObject * obj1 = 0 ;
28518 char * kwnames[] = {
28519 (char *) "self",(char *) "other", NULL
28520 };
28521
28522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28524 if (!SWIG_IsOK(res1)) {
28525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28526 }
28527 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28528 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28529 if (!SWIG_IsOK(res2)) {
28530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28531 }
28532 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 {
28540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28541 }
28542 return resultobj;
28543 fail:
28544 return NULL;
28545 }
28546
28547
28548 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28549 PyObject *resultobj = 0;
28550 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28551 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28552 bool result;
28553 void *argp1 = 0 ;
28554 int res1 = 0 ;
28555 void *argp2 = 0 ;
28556 int res2 = 0 ;
28557 PyObject * obj0 = 0 ;
28558 PyObject * obj1 = 0 ;
28559 char * kwnames[] = {
28560 (char *) "self",(char *) "other", NULL
28561 };
28562
28563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28565 if (!SWIG_IsOK(res1)) {
28566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28567 }
28568 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28570 if (!SWIG_IsOK(res2)) {
28571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28572 }
28573 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28574 {
28575 PyThreadState* __tstate = wxPyBeginAllowThreads();
28576 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28577 wxPyEndAllowThreads(__tstate);
28578 if (PyErr_Occurred()) SWIG_fail;
28579 }
28580 {
28581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28582 }
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28590 PyObject *resultobj = 0;
28591 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28592 bool result;
28593 void *argp1 = 0 ;
28594 int res1 = 0 ;
28595 PyObject *swig_obj[1] ;
28596
28597 if (!args) SWIG_fail;
28598 swig_obj[0] = args;
28599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28600 if (!SWIG_IsOK(res1)) {
28601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28602 }
28603 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28604 {
28605 PyThreadState* __tstate = wxPyBeginAllowThreads();
28606 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28607 wxPyEndAllowThreads(__tstate);
28608 if (PyErr_Occurred()) SWIG_fail;
28609 }
28610 {
28611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28612 }
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620 PyObject *resultobj = 0;
28621 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28622 bool result;
28623 void *argp1 = 0 ;
28624 int res1 = 0 ;
28625 PyObject *swig_obj[1] ;
28626
28627 if (!args) SWIG_fail;
28628 swig_obj[0] = args;
28629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28630 if (!SWIG_IsOK(res1)) {
28631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28632 }
28633 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 {
28641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28642 }
28643 return resultobj;
28644 fail:
28645 return NULL;
28646 }
28647
28648
28649 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650 PyObject *resultobj = 0;
28651 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28652 bool result;
28653 void *argp1 = 0 ;
28654 int res1 = 0 ;
28655 PyObject *swig_obj[1] ;
28656
28657 if (!args) SWIG_fail;
28658 swig_obj[0] = args;
28659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28660 if (!SWIG_IsOK(res1)) {
28661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28662 }
28663 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 {
28671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28672 }
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28680 PyObject *resultobj = 0;
28681 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28682 wxTimeSpan *arg2 = 0 ;
28683 bool result;
28684 void *argp1 = 0 ;
28685 int res1 = 0 ;
28686 void *argp2 = 0 ;
28687 int res2 = 0 ;
28688 PyObject * obj0 = 0 ;
28689 PyObject * obj1 = 0 ;
28690 char * kwnames[] = {
28691 (char *) "self",(char *) "ts", NULL
28692 };
28693
28694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28696 if (!SWIG_IsOK(res1)) {
28697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28698 }
28699 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28700 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28701 if (!SWIG_IsOK(res2)) {
28702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28703 }
28704 if (!argp2) {
28705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28706 }
28707 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28708 {
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 {
28715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28716 }
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj = 0;
28725 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28726 wxTimeSpan *arg2 = 0 ;
28727 bool result;
28728 void *argp1 = 0 ;
28729 int res1 = 0 ;
28730 void *argp2 = 0 ;
28731 int res2 = 0 ;
28732 PyObject * obj0 = 0 ;
28733 PyObject * obj1 = 0 ;
28734 char * kwnames[] = {
28735 (char *) "self",(char *) "ts", NULL
28736 };
28737
28738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28740 if (!SWIG_IsOK(res1)) {
28741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28742 }
28743 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28744 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28745 if (!SWIG_IsOK(res2)) {
28746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28747 }
28748 if (!argp2) {
28749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28750 }
28751 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 {
28759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28760 }
28761 return resultobj;
28762 fail:
28763 return NULL;
28764 }
28765
28766
28767 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28768 PyObject *resultobj = 0;
28769 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28770 wxTimeSpan *arg2 = 0 ;
28771 bool result;
28772 void *argp1 = 0 ;
28773 int res1 = 0 ;
28774 void *argp2 = 0 ;
28775 int res2 = 0 ;
28776 PyObject * obj0 = 0 ;
28777 PyObject * obj1 = 0 ;
28778 char * kwnames[] = {
28779 (char *) "self",(char *) "t", NULL
28780 };
28781
28782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28784 if (!SWIG_IsOK(res1)) {
28785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28786 }
28787 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28788 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28789 if (!SWIG_IsOK(res2)) {
28790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28791 }
28792 if (!argp2) {
28793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28794 }
28795 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28796 {
28797 PyThreadState* __tstate = wxPyBeginAllowThreads();
28798 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28799 wxPyEndAllowThreads(__tstate);
28800 if (PyErr_Occurred()) SWIG_fail;
28801 }
28802 {
28803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28804 }
28805 return resultobj;
28806 fail:
28807 return NULL;
28808 }
28809
28810
28811 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28812 PyObject *resultobj = 0;
28813 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28814 int result;
28815 void *argp1 = 0 ;
28816 int res1 = 0 ;
28817 PyObject *swig_obj[1] ;
28818
28819 if (!args) SWIG_fail;
28820 swig_obj[0] = args;
28821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28822 if (!SWIG_IsOK(res1)) {
28823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28824 }
28825 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28829 wxPyEndAllowThreads(__tstate);
28830 if (PyErr_Occurred()) SWIG_fail;
28831 }
28832 resultobj = SWIG_From_int(static_cast< int >(result));
28833 return resultobj;
28834 fail:
28835 return NULL;
28836 }
28837
28838
28839 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28840 PyObject *resultobj = 0;
28841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28842 int result;
28843 void *argp1 = 0 ;
28844 int res1 = 0 ;
28845 PyObject *swig_obj[1] ;
28846
28847 if (!args) SWIG_fail;
28848 swig_obj[0] = args;
28849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28850 if (!SWIG_IsOK(res1)) {
28851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28852 }
28853 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28854 {
28855 PyThreadState* __tstate = wxPyBeginAllowThreads();
28856 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28857 wxPyEndAllowThreads(__tstate);
28858 if (PyErr_Occurred()) SWIG_fail;
28859 }
28860 resultobj = SWIG_From_int(static_cast< int >(result));
28861 return resultobj;
28862 fail:
28863 return NULL;
28864 }
28865
28866
28867 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28868 PyObject *resultobj = 0;
28869 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28870 int result;
28871 void *argp1 = 0 ;
28872 int res1 = 0 ;
28873 PyObject *swig_obj[1] ;
28874
28875 if (!args) SWIG_fail;
28876 swig_obj[0] = args;
28877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28878 if (!SWIG_IsOK(res1)) {
28879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28880 }
28881 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28882 {
28883 PyThreadState* __tstate = wxPyBeginAllowThreads();
28884 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28885 wxPyEndAllowThreads(__tstate);
28886 if (PyErr_Occurred()) SWIG_fail;
28887 }
28888 resultobj = SWIG_From_int(static_cast< int >(result));
28889 return resultobj;
28890 fail:
28891 return NULL;
28892 }
28893
28894
28895 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28896 PyObject *resultobj = 0;
28897 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28898 int result;
28899 void *argp1 = 0 ;
28900 int res1 = 0 ;
28901 PyObject *swig_obj[1] ;
28902
28903 if (!args) SWIG_fail;
28904 swig_obj[0] = args;
28905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28908 }
28909 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 resultobj = SWIG_From_int(static_cast< int >(result));
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28924 PyObject *resultobj = 0;
28925 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28926 wxLongLong result;
28927 void *argp1 = 0 ;
28928 int res1 = 0 ;
28929 PyObject *swig_obj[1] ;
28930
28931 if (!args) SWIG_fail;
28932 swig_obj[0] = args;
28933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28934 if (!SWIG_IsOK(res1)) {
28935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28936 }
28937 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28938 {
28939 PyThreadState* __tstate = wxPyBeginAllowThreads();
28940 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28941 wxPyEndAllowThreads(__tstate);
28942 if (PyErr_Occurred()) SWIG_fail;
28943 }
28944 {
28945 PyObject *hi, *lo, *shifter, *shifted;
28946 hi = PyLong_FromLong( (&result)->GetHi() );
28947 lo = PyLong_FromLong( (&result)->GetLo() );
28948 shifter = PyLong_FromLong(32);
28949 shifted = PyNumber_Lshift(hi, shifter);
28950 resultobj = PyNumber_Or(shifted, lo);
28951 Py_DECREF(hi);
28952 Py_DECREF(lo);
28953 Py_DECREF(shifter);
28954 Py_DECREF(shifted);
28955 }
28956 return resultobj;
28957 fail:
28958 return NULL;
28959 }
28960
28961
28962 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28963 PyObject *resultobj = 0;
28964 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28965 wxLongLong result;
28966 void *argp1 = 0 ;
28967 int res1 = 0 ;
28968 PyObject *swig_obj[1] ;
28969
28970 if (!args) SWIG_fail;
28971 swig_obj[0] = args;
28972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28973 if (!SWIG_IsOK(res1)) {
28974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28975 }
28976 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28977 {
28978 PyThreadState* __tstate = wxPyBeginAllowThreads();
28979 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28980 wxPyEndAllowThreads(__tstate);
28981 if (PyErr_Occurred()) SWIG_fail;
28982 }
28983 {
28984 PyObject *hi, *lo, *shifter, *shifted;
28985 hi = PyLong_FromLong( (&result)->GetHi() );
28986 lo = PyLong_FromLong( (&result)->GetLo() );
28987 shifter = PyLong_FromLong(32);
28988 shifted = PyNumber_Lshift(hi, shifter);
28989 resultobj = PyNumber_Or(shifted, lo);
28990 Py_DECREF(hi);
28991 Py_DECREF(lo);
28992 Py_DECREF(shifter);
28993 Py_DECREF(shifted);
28994 }
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29002 PyObject *resultobj = 0;
29003 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29004 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29005 wxString *arg2 = (wxString *) &arg2_defvalue ;
29006 wxString result;
29007 void *argp1 = 0 ;
29008 int res1 = 0 ;
29009 bool temp2 = false ;
29010 PyObject * obj0 = 0 ;
29011 PyObject * obj1 = 0 ;
29012 char * kwnames[] = {
29013 (char *) "self",(char *) "format", NULL
29014 };
29015
29016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29018 if (!SWIG_IsOK(res1)) {
29019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29020 }
29021 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29022 if (obj1) {
29023 {
29024 arg2 = wxString_in_helper(obj1);
29025 if (arg2 == NULL) SWIG_fail;
29026 temp2 = true;
29027 }
29028 }
29029 {
29030 PyThreadState* __tstate = wxPyBeginAllowThreads();
29031 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 {
29036 #if wxUSE_UNICODE
29037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29038 #else
29039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29040 #endif
29041 }
29042 {
29043 if (temp2)
29044 delete arg2;
29045 }
29046 return resultobj;
29047 fail:
29048 {
29049 if (temp2)
29050 delete arg2;
29051 }
29052 return NULL;
29053 }
29054
29055
29056 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29057 PyObject *obj;
29058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29059 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
29060 return SWIG_Py_Void();
29061 }
29062
29063 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29064 return SWIG_Python_InitShadowInstance(args);
29065 }
29066
29067 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29068 PyObject *resultobj = 0;
29069 int arg1 = (int) 0 ;
29070 int arg2 = (int) 0 ;
29071 int arg3 = (int) 0 ;
29072 int arg4 = (int) 0 ;
29073 wxDateSpan *result = 0 ;
29074 int val1 ;
29075 int ecode1 = 0 ;
29076 int val2 ;
29077 int ecode2 = 0 ;
29078 int val3 ;
29079 int ecode3 = 0 ;
29080 int val4 ;
29081 int ecode4 = 0 ;
29082 PyObject * obj0 = 0 ;
29083 PyObject * obj1 = 0 ;
29084 PyObject * obj2 = 0 ;
29085 PyObject * obj3 = 0 ;
29086 char * kwnames[] = {
29087 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
29088 };
29089
29090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29091 if (obj0) {
29092 ecode1 = SWIG_AsVal_int(obj0, &val1);
29093 if (!SWIG_IsOK(ecode1)) {
29094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
29095 }
29096 arg1 = static_cast< int >(val1);
29097 }
29098 if (obj1) {
29099 ecode2 = SWIG_AsVal_int(obj1, &val2);
29100 if (!SWIG_IsOK(ecode2)) {
29101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
29102 }
29103 arg2 = static_cast< int >(val2);
29104 }
29105 if (obj2) {
29106 ecode3 = SWIG_AsVal_int(obj2, &val3);
29107 if (!SWIG_IsOK(ecode3)) {
29108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
29109 }
29110 arg3 = static_cast< int >(val3);
29111 }
29112 if (obj3) {
29113 ecode4 = SWIG_AsVal_int(obj3, &val4);
29114 if (!SWIG_IsOK(ecode4)) {
29115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
29116 }
29117 arg4 = static_cast< int >(val4);
29118 }
29119 {
29120 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29122 wxPyEndAllowThreads(__tstate);
29123 if (PyErr_Occurred()) SWIG_fail;
29124 }
29125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29126 return resultobj;
29127 fail:
29128 return NULL;
29129 }
29130
29131
29132 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29133 PyObject *resultobj = 0;
29134 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29135 void *argp1 = 0 ;
29136 int res1 = 0 ;
29137 PyObject *swig_obj[1] ;
29138
29139 if (!args) SWIG_fail;
29140 swig_obj[0] = args;
29141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29142 if (!SWIG_IsOK(res1)) {
29143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29144 }
29145 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29146 {
29147 PyThreadState* __tstate = wxPyBeginAllowThreads();
29148 delete arg1;
29149
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_Py_Void();
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29161 PyObject *resultobj = 0;
29162 int arg1 ;
29163 wxDateSpan result;
29164 int val1 ;
29165 int ecode1 = 0 ;
29166 PyObject * obj0 = 0 ;
29167 char * kwnames[] = {
29168 (char *) "days", NULL
29169 };
29170
29171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29172 ecode1 = SWIG_AsVal_int(obj0, &val1);
29173 if (!SWIG_IsOK(ecode1)) {
29174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29175 }
29176 arg1 = static_cast< int >(val1);
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = wxDateSpan::Days(arg1);
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29191 PyObject *resultobj = 0;
29192 wxDateSpan result;
29193
29194 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 result = wxDateSpan::Day();
29198 wxPyEndAllowThreads(__tstate);
29199 if (PyErr_Occurred()) SWIG_fail;
29200 }
29201 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29202 return resultobj;
29203 fail:
29204 return NULL;
29205 }
29206
29207
29208 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29209 PyObject *resultobj = 0;
29210 int arg1 ;
29211 wxDateSpan result;
29212 int val1 ;
29213 int ecode1 = 0 ;
29214 PyObject * obj0 = 0 ;
29215 char * kwnames[] = {
29216 (char *) "weeks", NULL
29217 };
29218
29219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29220 ecode1 = SWIG_AsVal_int(obj0, &val1);
29221 if (!SWIG_IsOK(ecode1)) {
29222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29223 }
29224 arg1 = static_cast< int >(val1);
29225 {
29226 PyThreadState* __tstate = wxPyBeginAllowThreads();
29227 result = wxDateSpan::Weeks(arg1);
29228 wxPyEndAllowThreads(__tstate);
29229 if (PyErr_Occurred()) SWIG_fail;
29230 }
29231 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29239 PyObject *resultobj = 0;
29240 wxDateSpan result;
29241
29242 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29243 {
29244 PyThreadState* __tstate = wxPyBeginAllowThreads();
29245 result = wxDateSpan::Week();
29246 wxPyEndAllowThreads(__tstate);
29247 if (PyErr_Occurred()) SWIG_fail;
29248 }
29249 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29250 return resultobj;
29251 fail:
29252 return NULL;
29253 }
29254
29255
29256 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29257 PyObject *resultobj = 0;
29258 int arg1 ;
29259 wxDateSpan result;
29260 int val1 ;
29261 int ecode1 = 0 ;
29262 PyObject * obj0 = 0 ;
29263 char * kwnames[] = {
29264 (char *) "mon", NULL
29265 };
29266
29267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29268 ecode1 = SWIG_AsVal_int(obj0, &val1);
29269 if (!SWIG_IsOK(ecode1)) {
29270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29271 }
29272 arg1 = static_cast< int >(val1);
29273 {
29274 PyThreadState* __tstate = wxPyBeginAllowThreads();
29275 result = wxDateSpan::Months(arg1);
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29287 PyObject *resultobj = 0;
29288 wxDateSpan result;
29289
29290 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 result = wxDateSpan::Month();
29294 wxPyEndAllowThreads(__tstate);
29295 if (PyErr_Occurred()) SWIG_fail;
29296 }
29297 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29298 return resultobj;
29299 fail:
29300 return NULL;
29301 }
29302
29303
29304 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29305 PyObject *resultobj = 0;
29306 int arg1 ;
29307 wxDateSpan result;
29308 int val1 ;
29309 int ecode1 = 0 ;
29310 PyObject * obj0 = 0 ;
29311 char * kwnames[] = {
29312 (char *) "years", NULL
29313 };
29314
29315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29316 ecode1 = SWIG_AsVal_int(obj0, &val1);
29317 if (!SWIG_IsOK(ecode1)) {
29318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29319 }
29320 arg1 = static_cast< int >(val1);
29321 {
29322 PyThreadState* __tstate = wxPyBeginAllowThreads();
29323 result = wxDateSpan::Years(arg1);
29324 wxPyEndAllowThreads(__tstate);
29325 if (PyErr_Occurred()) SWIG_fail;
29326 }
29327 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29328 return resultobj;
29329 fail:
29330 return NULL;
29331 }
29332
29333
29334 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29335 PyObject *resultobj = 0;
29336 wxDateSpan result;
29337
29338 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 result = wxDateSpan::Year();
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29353 PyObject *resultobj = 0;
29354 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29355 int arg2 ;
29356 wxDateSpan *result = 0 ;
29357 void *argp1 = 0 ;
29358 int res1 = 0 ;
29359 int val2 ;
29360 int ecode2 = 0 ;
29361 PyObject * obj0 = 0 ;
29362 PyObject * obj1 = 0 ;
29363 char * kwnames[] = {
29364 (char *) "self",(char *) "n", NULL
29365 };
29366
29367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29369 if (!SWIG_IsOK(res1)) {
29370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29371 }
29372 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29373 ecode2 = SWIG_AsVal_int(obj1, &val2);
29374 if (!SWIG_IsOK(ecode2)) {
29375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29376 }
29377 arg2 = static_cast< int >(val2);
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 {
29381 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29382 result = (wxDateSpan *) &_result_ref;
29383 }
29384 wxPyEndAllowThreads(__tstate);
29385 if (PyErr_Occurred()) SWIG_fail;
29386 }
29387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29395 PyObject *resultobj = 0;
29396 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29397 int arg2 ;
29398 wxDateSpan *result = 0 ;
29399 void *argp1 = 0 ;
29400 int res1 = 0 ;
29401 int val2 ;
29402 int ecode2 = 0 ;
29403 PyObject * obj0 = 0 ;
29404 PyObject * obj1 = 0 ;
29405 char * kwnames[] = {
29406 (char *) "self",(char *) "n", NULL
29407 };
29408
29409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29411 if (!SWIG_IsOK(res1)) {
29412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29413 }
29414 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29415 ecode2 = SWIG_AsVal_int(obj1, &val2);
29416 if (!SWIG_IsOK(ecode2)) {
29417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29418 }
29419 arg2 = static_cast< int >(val2);
29420 {
29421 PyThreadState* __tstate = wxPyBeginAllowThreads();
29422 {
29423 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29424 result = (wxDateSpan *) &_result_ref;
29425 }
29426 wxPyEndAllowThreads(__tstate);
29427 if (PyErr_Occurred()) SWIG_fail;
29428 }
29429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29430 return resultobj;
29431 fail:
29432 return NULL;
29433 }
29434
29435
29436 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29437 PyObject *resultobj = 0;
29438 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29439 int arg2 ;
29440 wxDateSpan *result = 0 ;
29441 void *argp1 = 0 ;
29442 int res1 = 0 ;
29443 int val2 ;
29444 int ecode2 = 0 ;
29445 PyObject * obj0 = 0 ;
29446 PyObject * obj1 = 0 ;
29447 char * kwnames[] = {
29448 (char *) "self",(char *) "n", NULL
29449 };
29450
29451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29453 if (!SWIG_IsOK(res1)) {
29454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29455 }
29456 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29457 ecode2 = SWIG_AsVal_int(obj1, &val2);
29458 if (!SWIG_IsOK(ecode2)) {
29459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29460 }
29461 arg2 = static_cast< int >(val2);
29462 {
29463 PyThreadState* __tstate = wxPyBeginAllowThreads();
29464 {
29465 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29466 result = (wxDateSpan *) &_result_ref;
29467 }
29468 wxPyEndAllowThreads(__tstate);
29469 if (PyErr_Occurred()) SWIG_fail;
29470 }
29471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29479 PyObject *resultobj = 0;
29480 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29481 int arg2 ;
29482 wxDateSpan *result = 0 ;
29483 void *argp1 = 0 ;
29484 int res1 = 0 ;
29485 int val2 ;
29486 int ecode2 = 0 ;
29487 PyObject * obj0 = 0 ;
29488 PyObject * obj1 = 0 ;
29489 char * kwnames[] = {
29490 (char *) "self",(char *) "n", NULL
29491 };
29492
29493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29495 if (!SWIG_IsOK(res1)) {
29496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29497 }
29498 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29499 ecode2 = SWIG_AsVal_int(obj1, &val2);
29500 if (!SWIG_IsOK(ecode2)) {
29501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29502 }
29503 arg2 = static_cast< int >(val2);
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 {
29507 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29508 result = (wxDateSpan *) &_result_ref;
29509 }
29510 wxPyEndAllowThreads(__tstate);
29511 if (PyErr_Occurred()) SWIG_fail;
29512 }
29513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29514 return resultobj;
29515 fail:
29516 return NULL;
29517 }
29518
29519
29520 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29521 PyObject *resultobj = 0;
29522 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29523 int result;
29524 void *argp1 = 0 ;
29525 int res1 = 0 ;
29526 PyObject *swig_obj[1] ;
29527
29528 if (!args) SWIG_fail;
29529 swig_obj[0] = args;
29530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29531 if (!SWIG_IsOK(res1)) {
29532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29533 }
29534 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29535 {
29536 PyThreadState* __tstate = wxPyBeginAllowThreads();
29537 result = (int)((wxDateSpan const *)arg1)->GetYears();
29538 wxPyEndAllowThreads(__tstate);
29539 if (PyErr_Occurred()) SWIG_fail;
29540 }
29541 resultobj = SWIG_From_int(static_cast< int >(result));
29542 return resultobj;
29543 fail:
29544 return NULL;
29545 }
29546
29547
29548 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29549 PyObject *resultobj = 0;
29550 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29551 int result;
29552 void *argp1 = 0 ;
29553 int res1 = 0 ;
29554 PyObject *swig_obj[1] ;
29555
29556 if (!args) SWIG_fail;
29557 swig_obj[0] = args;
29558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29559 if (!SWIG_IsOK(res1)) {
29560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29561 }
29562 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29563 {
29564 PyThreadState* __tstate = wxPyBeginAllowThreads();
29565 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29566 wxPyEndAllowThreads(__tstate);
29567 if (PyErr_Occurred()) SWIG_fail;
29568 }
29569 resultobj = SWIG_From_int(static_cast< int >(result));
29570 return resultobj;
29571 fail:
29572 return NULL;
29573 }
29574
29575
29576 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29577 PyObject *resultobj = 0;
29578 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29579 int result;
29580 void *argp1 = 0 ;
29581 int res1 = 0 ;
29582 PyObject *swig_obj[1] ;
29583
29584 if (!args) SWIG_fail;
29585 swig_obj[0] = args;
29586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29587 if (!SWIG_IsOK(res1)) {
29588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29589 }
29590 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29591 {
29592 PyThreadState* __tstate = wxPyBeginAllowThreads();
29593 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29594 wxPyEndAllowThreads(__tstate);
29595 if (PyErr_Occurred()) SWIG_fail;
29596 }
29597 resultobj = SWIG_From_int(static_cast< int >(result));
29598 return resultobj;
29599 fail:
29600 return NULL;
29601 }
29602
29603
29604 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29605 PyObject *resultobj = 0;
29606 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29607 int result;
29608 void *argp1 = 0 ;
29609 int res1 = 0 ;
29610 PyObject *swig_obj[1] ;
29611
29612 if (!args) SWIG_fail;
29613 swig_obj[0] = args;
29614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29615 if (!SWIG_IsOK(res1)) {
29616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29617 }
29618 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 result = (int)((wxDateSpan const *)arg1)->GetDays();
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 resultobj = SWIG_From_int(static_cast< int >(result));
29626 return resultobj;
29627 fail:
29628 return NULL;
29629 }
29630
29631
29632 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29633 PyObject *resultobj = 0;
29634 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29635 int result;
29636 void *argp1 = 0 ;
29637 int res1 = 0 ;
29638 PyObject *swig_obj[1] ;
29639
29640 if (!args) SWIG_fail;
29641 swig_obj[0] = args;
29642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29643 if (!SWIG_IsOK(res1)) {
29644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29645 }
29646 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29647 {
29648 PyThreadState* __tstate = wxPyBeginAllowThreads();
29649 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 resultobj = SWIG_From_int(static_cast< int >(result));
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29661 PyObject *resultobj = 0;
29662 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29663 wxDateSpan *arg2 = 0 ;
29664 wxDateSpan *result = 0 ;
29665 void *argp1 = 0 ;
29666 int res1 = 0 ;
29667 void *argp2 = 0 ;
29668 int res2 = 0 ;
29669 PyObject * obj0 = 0 ;
29670 PyObject * obj1 = 0 ;
29671 char * kwnames[] = {
29672 (char *) "self",(char *) "other", NULL
29673 };
29674
29675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29677 if (!SWIG_IsOK(res1)) {
29678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29679 }
29680 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29681 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29682 if (!SWIG_IsOK(res2)) {
29683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29684 }
29685 if (!argp2) {
29686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29687 }
29688 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 {
29692 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29693 result = (wxDateSpan *) &_result_ref;
29694 }
29695 wxPyEndAllowThreads(__tstate);
29696 if (PyErr_Occurred()) SWIG_fail;
29697 }
29698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29706 PyObject *resultobj = 0;
29707 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29708 wxDateSpan *arg2 = 0 ;
29709 wxDateSpan *result = 0 ;
29710 void *argp1 = 0 ;
29711 int res1 = 0 ;
29712 void *argp2 = 0 ;
29713 int res2 = 0 ;
29714 PyObject * obj0 = 0 ;
29715 PyObject * obj1 = 0 ;
29716 char * kwnames[] = {
29717 (char *) "self",(char *) "other", NULL
29718 };
29719
29720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29722 if (!SWIG_IsOK(res1)) {
29723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29724 }
29725 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29726 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29727 if (!SWIG_IsOK(res2)) {
29728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29729 }
29730 if (!argp2) {
29731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29732 }
29733 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 {
29737 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29738 result = (wxDateSpan *) &_result_ref;
29739 }
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29751 PyObject *resultobj = 0;
29752 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29753 wxDateSpan *result = 0 ;
29754 void *argp1 = 0 ;
29755 int res1 = 0 ;
29756 PyObject *swig_obj[1] ;
29757
29758 if (!args) SWIG_fail;
29759 swig_obj[0] = args;
29760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29761 if (!SWIG_IsOK(res1)) {
29762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29763 }
29764 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29765 {
29766 PyThreadState* __tstate = wxPyBeginAllowThreads();
29767 {
29768 wxDateSpan &_result_ref = (arg1)->Neg();
29769 result = (wxDateSpan *) &_result_ref;
29770 }
29771 wxPyEndAllowThreads(__tstate);
29772 if (PyErr_Occurred()) SWIG_fail;
29773 }
29774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29775 return resultobj;
29776 fail:
29777 return NULL;
29778 }
29779
29780
29781 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29782 PyObject *resultobj = 0;
29783 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29784 int arg2 ;
29785 wxDateSpan *result = 0 ;
29786 void *argp1 = 0 ;
29787 int res1 = 0 ;
29788 int val2 ;
29789 int ecode2 = 0 ;
29790 PyObject * obj0 = 0 ;
29791 PyObject * obj1 = 0 ;
29792 char * kwnames[] = {
29793 (char *) "self",(char *) "factor", NULL
29794 };
29795
29796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29798 if (!SWIG_IsOK(res1)) {
29799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29800 }
29801 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29802 ecode2 = SWIG_AsVal_int(obj1, &val2);
29803 if (!SWIG_IsOK(ecode2)) {
29804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29805 }
29806 arg2 = static_cast< int >(val2);
29807 {
29808 PyThreadState* __tstate = wxPyBeginAllowThreads();
29809 {
29810 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29811 result = (wxDateSpan *) &_result_ref;
29812 }
29813 wxPyEndAllowThreads(__tstate);
29814 if (PyErr_Occurred()) SWIG_fail;
29815 }
29816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29817 return resultobj;
29818 fail:
29819 return NULL;
29820 }
29821
29822
29823 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29824 PyObject *resultobj = 0;
29825 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29826 wxDateSpan *arg2 = 0 ;
29827 wxDateSpan *result = 0 ;
29828 void *argp1 = 0 ;
29829 int res1 = 0 ;
29830 void *argp2 = 0 ;
29831 int res2 = 0 ;
29832 PyObject * obj0 = 0 ;
29833 PyObject * obj1 = 0 ;
29834 char * kwnames[] = {
29835 (char *) "self",(char *) "other", NULL
29836 };
29837
29838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29840 if (!SWIG_IsOK(res1)) {
29841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29842 }
29843 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29844 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29845 if (!SWIG_IsOK(res2)) {
29846 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29847 }
29848 if (!argp2) {
29849 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29850 }
29851 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 {
29855 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29856 result = (wxDateSpan *) &_result_ref;
29857 }
29858 wxPyEndAllowThreads(__tstate);
29859 if (PyErr_Occurred()) SWIG_fail;
29860 }
29861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj = 0;
29870 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29871 wxDateSpan *arg2 = 0 ;
29872 wxDateSpan *result = 0 ;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 void *argp2 = 0 ;
29876 int res2 = 0 ;
29877 PyObject * obj0 = 0 ;
29878 PyObject * obj1 = 0 ;
29879 char * kwnames[] = {
29880 (char *) "self",(char *) "other", NULL
29881 };
29882
29883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29885 if (!SWIG_IsOK(res1)) {
29886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29887 }
29888 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29889 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29890 if (!SWIG_IsOK(res2)) {
29891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29892 }
29893 if (!argp2) {
29894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29895 }
29896 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 {
29900 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29901 result = (wxDateSpan *) &_result_ref;
29902 }
29903 wxPyEndAllowThreads(__tstate);
29904 if (PyErr_Occurred()) SWIG_fail;
29905 }
29906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29907 return resultobj;
29908 fail:
29909 return NULL;
29910 }
29911
29912
29913 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29914 PyObject *resultobj = 0;
29915 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29916 wxDateSpan *result = 0 ;
29917 void *argp1 = 0 ;
29918 int res1 = 0 ;
29919 PyObject *swig_obj[1] ;
29920
29921 if (!args) SWIG_fail;
29922 swig_obj[0] = args;
29923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29924 if (!SWIG_IsOK(res1)) {
29925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29926 }
29927 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29928 {
29929 PyThreadState* __tstate = wxPyBeginAllowThreads();
29930 {
29931 wxDateSpan &_result_ref = (arg1)->operator -();
29932 result = (wxDateSpan *) &_result_ref;
29933 }
29934 wxPyEndAllowThreads(__tstate);
29935 if (PyErr_Occurred()) SWIG_fail;
29936 }
29937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29938 return resultobj;
29939 fail:
29940 return NULL;
29941 }
29942
29943
29944 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29945 PyObject *resultobj = 0;
29946 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29947 int arg2 ;
29948 wxDateSpan *result = 0 ;
29949 void *argp1 = 0 ;
29950 int res1 = 0 ;
29951 int val2 ;
29952 int ecode2 = 0 ;
29953 PyObject * obj0 = 0 ;
29954 PyObject * obj1 = 0 ;
29955 char * kwnames[] = {
29956 (char *) "self",(char *) "factor", NULL
29957 };
29958
29959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29961 if (!SWIG_IsOK(res1)) {
29962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29963 }
29964 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29965 ecode2 = SWIG_AsVal_int(obj1, &val2);
29966 if (!SWIG_IsOK(ecode2)) {
29967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29968 }
29969 arg2 = static_cast< int >(val2);
29970 {
29971 PyThreadState* __tstate = wxPyBeginAllowThreads();
29972 {
29973 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29974 result = (wxDateSpan *) &_result_ref;
29975 }
29976 wxPyEndAllowThreads(__tstate);
29977 if (PyErr_Occurred()) SWIG_fail;
29978 }
29979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29980 return resultobj;
29981 fail:
29982 return NULL;
29983 }
29984
29985
29986 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29987 PyObject *resultobj = 0;
29988 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29989 wxDateSpan *arg2 = 0 ;
29990 wxDateSpan result;
29991 void *argp1 = 0 ;
29992 int res1 = 0 ;
29993 void *argp2 = 0 ;
29994 int res2 = 0 ;
29995 PyObject * obj0 = 0 ;
29996 PyObject * obj1 = 0 ;
29997 char * kwnames[] = {
29998 (char *) "self",(char *) "other", NULL
29999 };
30000
30001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30003 if (!SWIG_IsOK(res1)) {
30004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30005 }
30006 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30008 if (!SWIG_IsOK(res2)) {
30009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30010 }
30011 if (!argp2) {
30012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30013 }
30014 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30022 return resultobj;
30023 fail:
30024 return NULL;
30025 }
30026
30027
30028 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30029 PyObject *resultobj = 0;
30030 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30031 wxDateSpan *arg2 = 0 ;
30032 wxDateSpan result;
30033 void *argp1 = 0 ;
30034 int res1 = 0 ;
30035 void *argp2 = 0 ;
30036 int res2 = 0 ;
30037 PyObject * obj0 = 0 ;
30038 PyObject * obj1 = 0 ;
30039 char * kwnames[] = {
30040 (char *) "self",(char *) "other", NULL
30041 };
30042
30043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30045 if (!SWIG_IsOK(res1)) {
30046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30047 }
30048 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30049 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30050 if (!SWIG_IsOK(res2)) {
30051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30052 }
30053 if (!argp2) {
30054 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30055 }
30056 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
30060 wxPyEndAllowThreads(__tstate);
30061 if (PyErr_Occurred()) SWIG_fail;
30062 }
30063 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30071 PyObject *resultobj = 0;
30072 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30073 int arg2 ;
30074 wxDateSpan result;
30075 void *argp1 = 0 ;
30076 int res1 = 0 ;
30077 int val2 ;
30078 int ecode2 = 0 ;
30079 PyObject * obj0 = 0 ;
30080 PyObject * obj1 = 0 ;
30081 char * kwnames[] = {
30082 (char *) "self",(char *) "n", NULL
30083 };
30084
30085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
30086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30087 if (!SWIG_IsOK(res1)) {
30088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30089 }
30090 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30091 ecode2 = SWIG_AsVal_int(obj1, &val2);
30092 if (!SWIG_IsOK(ecode2)) {
30093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
30094 }
30095 arg2 = static_cast< int >(val2);
30096 {
30097 PyThreadState* __tstate = wxPyBeginAllowThreads();
30098 result = wxDateSpan___mul__(arg1,arg2);
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30103 return resultobj;
30104 fail:
30105 return NULL;
30106 }
30107
30108
30109 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30110 PyObject *resultobj = 0;
30111 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30112 int arg2 ;
30113 wxDateSpan result;
30114 void *argp1 = 0 ;
30115 int res1 = 0 ;
30116 int val2 ;
30117 int ecode2 = 0 ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 char * kwnames[] = {
30121 (char *) "self",(char *) "n", NULL
30122 };
30123
30124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30126 if (!SWIG_IsOK(res1)) {
30127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30128 }
30129 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30130 ecode2 = SWIG_AsVal_int(obj1, &val2);
30131 if (!SWIG_IsOK(ecode2)) {
30132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30133 }
30134 arg2 = static_cast< int >(val2);
30135 {
30136 PyThreadState* __tstate = wxPyBeginAllowThreads();
30137 result = wxDateSpan___rmul__(arg1,arg2);
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30142 return resultobj;
30143 fail:
30144 return NULL;
30145 }
30146
30147
30148 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30149 PyObject *resultobj = 0;
30150 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30151 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30152 bool result;
30153 void *argp1 = 0 ;
30154 int res1 = 0 ;
30155 void *argp2 = 0 ;
30156 int res2 = 0 ;
30157 PyObject * obj0 = 0 ;
30158 PyObject * obj1 = 0 ;
30159 char * kwnames[] = {
30160 (char *) "self",(char *) "other", NULL
30161 };
30162
30163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30165 if (!SWIG_IsOK(res1)) {
30166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30167 }
30168 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30170 if (!SWIG_IsOK(res2)) {
30171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30172 }
30173 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30174 {
30175 PyThreadState* __tstate = wxPyBeginAllowThreads();
30176 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30177 wxPyEndAllowThreads(__tstate);
30178 if (PyErr_Occurred()) SWIG_fail;
30179 }
30180 {
30181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30182 }
30183 return resultobj;
30184 fail:
30185 return NULL;
30186 }
30187
30188
30189 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj = 0;
30191 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30192 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30193 bool result;
30194 void *argp1 = 0 ;
30195 int res1 = 0 ;
30196 void *argp2 = 0 ;
30197 int res2 = 0 ;
30198 PyObject * obj0 = 0 ;
30199 PyObject * obj1 = 0 ;
30200 char * kwnames[] = {
30201 (char *) "self",(char *) "other", NULL
30202 };
30203
30204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30206 if (!SWIG_IsOK(res1)) {
30207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30208 }
30209 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30211 if (!SWIG_IsOK(res2)) {
30212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30213 }
30214 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30215 {
30216 PyThreadState* __tstate = wxPyBeginAllowThreads();
30217 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30218 wxPyEndAllowThreads(__tstate);
30219 if (PyErr_Occurred()) SWIG_fail;
30220 }
30221 {
30222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30223 }
30224 return resultobj;
30225 fail:
30226 return NULL;
30227 }
30228
30229
30230 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30231 PyObject *obj;
30232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30233 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30234 return SWIG_Py_Void();
30235 }
30236
30237 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30238 return SWIG_Python_InitShadowInstance(args);
30239 }
30240
30241 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30242 PyObject *resultobj = 0;
30243 long result;
30244
30245 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30246 {
30247 PyThreadState* __tstate = wxPyBeginAllowThreads();
30248 result = (long)wxGetLocalTime();
30249 wxPyEndAllowThreads(__tstate);
30250 if (PyErr_Occurred()) SWIG_fail;
30251 }
30252 resultobj = SWIG_From_long(static_cast< long >(result));
30253 return resultobj;
30254 fail:
30255 return NULL;
30256 }
30257
30258
30259 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30260 PyObject *resultobj = 0;
30261 long result;
30262
30263 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30264 {
30265 PyThreadState* __tstate = wxPyBeginAllowThreads();
30266 result = (long)wxGetUTCTime();
30267 wxPyEndAllowThreads(__tstate);
30268 if (PyErr_Occurred()) SWIG_fail;
30269 }
30270 resultobj = SWIG_From_long(static_cast< long >(result));
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30278 PyObject *resultobj = 0;
30279 long result;
30280
30281 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 result = (long)wxGetCurrentTime();
30285 wxPyEndAllowThreads(__tstate);
30286 if (PyErr_Occurred()) SWIG_fail;
30287 }
30288 resultobj = SWIG_From_long(static_cast< long >(result));
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30296 PyObject *resultobj = 0;
30297 wxLongLong result;
30298
30299 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30300 {
30301 PyThreadState* __tstate = wxPyBeginAllowThreads();
30302 result = wxGetLocalTimeMillis();
30303 wxPyEndAllowThreads(__tstate);
30304 if (PyErr_Occurred()) SWIG_fail;
30305 }
30306 {
30307 PyObject *hi, *lo, *shifter, *shifted;
30308 hi = PyLong_FromLong( (&result)->GetHi() );
30309 lo = PyLong_FromLong( (&result)->GetLo() );
30310 shifter = PyLong_FromLong(32);
30311 shifted = PyNumber_Lshift(hi, shifter);
30312 resultobj = PyNumber_Or(shifted, lo);
30313 Py_DECREF(hi);
30314 Py_DECREF(lo);
30315 Py_DECREF(shifter);
30316 Py_DECREF(shifted);
30317 }
30318 return resultobj;
30319 fail:
30320 return NULL;
30321 }
30322
30323
30324 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30325 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30326 return 1;
30327 }
30328
30329
30330 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30331 PyObject *pyobj = 0;
30332
30333 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30334 return pyobj;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj = 0;
30340 wxDataFormatId arg1 ;
30341 wxDataFormat *result = 0 ;
30342 int val1 ;
30343 int ecode1 = 0 ;
30344 PyObject * obj0 = 0 ;
30345 char * kwnames[] = {
30346 (char *) "type", NULL
30347 };
30348
30349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30350 ecode1 = SWIG_AsVal_int(obj0, &val1);
30351 if (!SWIG_IsOK(ecode1)) {
30352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30353 }
30354 arg1 = static_cast< wxDataFormatId >(val1);
30355 {
30356 PyThreadState* __tstate = wxPyBeginAllowThreads();
30357 result = (wxDataFormat *)new wxDataFormat(arg1);
30358 wxPyEndAllowThreads(__tstate);
30359 if (PyErr_Occurred()) SWIG_fail;
30360 }
30361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30362 return resultobj;
30363 fail:
30364 return NULL;
30365 }
30366
30367
30368 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30369 PyObject *resultobj = 0;
30370 wxString *arg1 = 0 ;
30371 wxDataFormat *result = 0 ;
30372 bool temp1 = false ;
30373 PyObject * obj0 = 0 ;
30374 char * kwnames[] = {
30375 (char *) "format", NULL
30376 };
30377
30378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30379 {
30380 arg1 = wxString_in_helper(obj0);
30381 if (arg1 == NULL) SWIG_fail;
30382 temp1 = true;
30383 }
30384 {
30385 PyThreadState* __tstate = wxPyBeginAllowThreads();
30386 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30387 wxPyEndAllowThreads(__tstate);
30388 if (PyErr_Occurred()) SWIG_fail;
30389 }
30390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30391 {
30392 if (temp1)
30393 delete arg1;
30394 }
30395 return resultobj;
30396 fail:
30397 {
30398 if (temp1)
30399 delete arg1;
30400 }
30401 return NULL;
30402 }
30403
30404
30405 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30406 PyObject *resultobj = 0;
30407 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30408 void *argp1 = 0 ;
30409 int res1 = 0 ;
30410 PyObject *swig_obj[1] ;
30411
30412 if (!args) SWIG_fail;
30413 swig_obj[0] = args;
30414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30415 if (!SWIG_IsOK(res1)) {
30416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30417 }
30418 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30419 {
30420 PyThreadState* __tstate = wxPyBeginAllowThreads();
30421 delete arg1;
30422
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 resultobj = SWIG_Py_Void();
30427 return resultobj;
30428 fail:
30429 return NULL;
30430 }
30431
30432
30433 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30434 PyObject *resultobj = 0;
30435 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30436 wxDataFormatId arg2 ;
30437 bool result;
30438 void *argp1 = 0 ;
30439 int res1 = 0 ;
30440 int val2 ;
30441 int ecode2 = 0 ;
30442
30443 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30445 if (!SWIG_IsOK(res1)) {
30446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30447 }
30448 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30449 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30450 if (!SWIG_IsOK(ecode2)) {
30451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30452 }
30453 arg2 = static_cast< wxDataFormatId >(val2);
30454 {
30455 PyThreadState* __tstate = wxPyBeginAllowThreads();
30456 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30457 wxPyEndAllowThreads(__tstate);
30458 if (PyErr_Occurred()) SWIG_fail;
30459 }
30460 {
30461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30462 }
30463 return resultobj;
30464 fail:
30465 return NULL;
30466 }
30467
30468
30469 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30470 PyObject *resultobj = 0;
30471 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30472 wxDataFormatId arg2 ;
30473 bool result;
30474 void *argp1 = 0 ;
30475 int res1 = 0 ;
30476 int val2 ;
30477 int ecode2 = 0 ;
30478
30479 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30481 if (!SWIG_IsOK(res1)) {
30482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30483 }
30484 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30485 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30486 if (!SWIG_IsOK(ecode2)) {
30487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30488 }
30489 arg2 = static_cast< wxDataFormatId >(val2);
30490 {
30491 PyThreadState* __tstate = wxPyBeginAllowThreads();
30492 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30493 wxPyEndAllowThreads(__tstate);
30494 if (PyErr_Occurred()) SWIG_fail;
30495 }
30496 {
30497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30498 }
30499 return resultobj;
30500 fail:
30501 return NULL;
30502 }
30503
30504
30505 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30506 PyObject *resultobj = 0;
30507 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30508 wxDataFormat *arg2 = 0 ;
30509 bool result;
30510 void *argp1 = 0 ;
30511 int res1 = 0 ;
30512 void *argp2 = 0 ;
30513 int res2 = 0 ;
30514
30515 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30517 if (!SWIG_IsOK(res1)) {
30518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30519 }
30520 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30521 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30522 if (!SWIG_IsOK(res2)) {
30523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30524 }
30525 if (!argp2) {
30526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30527 }
30528 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30529 {
30530 PyThreadState* __tstate = wxPyBeginAllowThreads();
30531 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30532 wxPyEndAllowThreads(__tstate);
30533 if (PyErr_Occurred()) SWIG_fail;
30534 }
30535 {
30536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30537 }
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30545 int argc;
30546 PyObject *argv[3];
30547
30548 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30549 --argc;
30550 if (argc == 2) {
30551 int _v = 0;
30552 {
30553 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30554 _v = SWIG_CheckState(res);
30555 }
30556 if (!_v) goto check_1;
30557 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30558 }
30559 check_1:
30560
30561 if (argc == 2) {
30562 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30563 }
30564
30565 fail:
30566 Py_INCREF(Py_NotImplemented);
30567 return Py_NotImplemented;
30568 }
30569
30570
30571 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30572 PyObject *resultobj = 0;
30573 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30574 wxDataFormat *arg2 = 0 ;
30575 bool result;
30576 void *argp1 = 0 ;
30577 int res1 = 0 ;
30578 void *argp2 = 0 ;
30579 int res2 = 0 ;
30580
30581 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30583 if (!SWIG_IsOK(res1)) {
30584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30585 }
30586 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30587 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30588 if (!SWIG_IsOK(res2)) {
30589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30590 }
30591 if (!argp2) {
30592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30593 }
30594 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30595 {
30596 PyThreadState* __tstate = wxPyBeginAllowThreads();
30597 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30598 wxPyEndAllowThreads(__tstate);
30599 if (PyErr_Occurred()) SWIG_fail;
30600 }
30601 {
30602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30603 }
30604 return resultobj;
30605 fail:
30606 return NULL;
30607 }
30608
30609
30610 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30611 int argc;
30612 PyObject *argv[3];
30613
30614 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30615 --argc;
30616 if (argc == 2) {
30617 int _v = 0;
30618 {
30619 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30620 _v = SWIG_CheckState(res);
30621 }
30622 if (!_v) goto check_1;
30623 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30624 }
30625 check_1:
30626
30627 if (argc == 2) {
30628 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30629 }
30630
30631 fail:
30632 Py_INCREF(Py_NotImplemented);
30633 return Py_NotImplemented;
30634 }
30635
30636
30637 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30638 PyObject *resultobj = 0;
30639 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30640 wxDataFormatId arg2 ;
30641 void *argp1 = 0 ;
30642 int res1 = 0 ;
30643 int val2 ;
30644 int ecode2 = 0 ;
30645 PyObject * obj0 = 0 ;
30646 PyObject * obj1 = 0 ;
30647 char * kwnames[] = {
30648 (char *) "self",(char *) "format", NULL
30649 };
30650
30651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30653 if (!SWIG_IsOK(res1)) {
30654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30655 }
30656 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30657 ecode2 = SWIG_AsVal_int(obj1, &val2);
30658 if (!SWIG_IsOK(ecode2)) {
30659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30660 }
30661 arg2 = static_cast< wxDataFormatId >(val2);
30662 {
30663 PyThreadState* __tstate = wxPyBeginAllowThreads();
30664 (arg1)->SetType(arg2);
30665 wxPyEndAllowThreads(__tstate);
30666 if (PyErr_Occurred()) SWIG_fail;
30667 }
30668 resultobj = SWIG_Py_Void();
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30676 PyObject *resultobj = 0;
30677 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30678 wxDataFormatId result;
30679 void *argp1 = 0 ;
30680 int res1 = 0 ;
30681 PyObject *swig_obj[1] ;
30682
30683 if (!args) SWIG_fail;
30684 swig_obj[0] = args;
30685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30686 if (!SWIG_IsOK(res1)) {
30687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30688 }
30689 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30690 {
30691 PyThreadState* __tstate = wxPyBeginAllowThreads();
30692 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30693 wxPyEndAllowThreads(__tstate);
30694 if (PyErr_Occurred()) SWIG_fail;
30695 }
30696 resultobj = SWIG_From_int(static_cast< int >(result));
30697 return resultobj;
30698 fail:
30699 return NULL;
30700 }
30701
30702
30703 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30704 PyObject *resultobj = 0;
30705 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30706 wxString result;
30707 void *argp1 = 0 ;
30708 int res1 = 0 ;
30709 PyObject *swig_obj[1] ;
30710
30711 if (!args) SWIG_fail;
30712 swig_obj[0] = args;
30713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30714 if (!SWIG_IsOK(res1)) {
30715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30716 }
30717 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30718 {
30719 PyThreadState* __tstate = wxPyBeginAllowThreads();
30720 result = ((wxDataFormat const *)arg1)->GetId();
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 {
30725 #if wxUSE_UNICODE
30726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30727 #else
30728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30729 #endif
30730 }
30731 return resultobj;
30732 fail:
30733 return NULL;
30734 }
30735
30736
30737 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30738 PyObject *resultobj = 0;
30739 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30740 wxString *arg2 = 0 ;
30741 void *argp1 = 0 ;
30742 int res1 = 0 ;
30743 bool temp2 = false ;
30744 PyObject * obj0 = 0 ;
30745 PyObject * obj1 = 0 ;
30746 char * kwnames[] = {
30747 (char *) "self",(char *) "format", NULL
30748 };
30749
30750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30752 if (!SWIG_IsOK(res1)) {
30753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30754 }
30755 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30756 {
30757 arg2 = wxString_in_helper(obj1);
30758 if (arg2 == NULL) SWIG_fail;
30759 temp2 = true;
30760 }
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 (arg1)->SetId((wxString const &)*arg2);
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_Py_Void();
30768 {
30769 if (temp2)
30770 delete arg2;
30771 }
30772 return resultobj;
30773 fail:
30774 {
30775 if (temp2)
30776 delete arg2;
30777 }
30778 return NULL;
30779 }
30780
30781
30782 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30783 PyObject *obj;
30784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30785 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30786 return SWIG_Py_Void();
30787 }
30788
30789 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30790 return SWIG_Python_InitShadowInstance(args);
30791 }
30792
30793 SWIGINTERN int FormatInvalid_set(PyObject *) {
30794 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30795 return 1;
30796 }
30797
30798
30799 SWIGINTERN PyObject *FormatInvalid_get(void) {
30800 PyObject *pyobj = 0;
30801
30802 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30803 return pyobj;
30804 }
30805
30806
30807 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30808 PyObject *resultobj = 0;
30809 wxDataObject *arg1 = (wxDataObject *) 0 ;
30810 void *argp1 = 0 ;
30811 int res1 = 0 ;
30812 PyObject *swig_obj[1] ;
30813
30814 if (!args) SWIG_fail;
30815 swig_obj[0] = args;
30816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30817 if (!SWIG_IsOK(res1)) {
30818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30819 }
30820 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 delete arg1;
30824
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 resultobj = SWIG_Py_Void();
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30836 PyObject *resultobj = 0;
30837 wxDataObject *arg1 = (wxDataObject *) 0 ;
30838 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30839 SwigValueWrapper<wxDataFormat > result;
30840 void *argp1 = 0 ;
30841 int res1 = 0 ;
30842 int val2 ;
30843 int ecode2 = 0 ;
30844 PyObject * obj0 = 0 ;
30845 PyObject * obj1 = 0 ;
30846 char * kwnames[] = {
30847 (char *) "self",(char *) "dir", NULL
30848 };
30849
30850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30852 if (!SWIG_IsOK(res1)) {
30853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30854 }
30855 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30856 if (obj1) {
30857 ecode2 = SWIG_AsVal_int(obj1, &val2);
30858 if (!SWIG_IsOK(ecode2)) {
30859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30860 }
30861 arg2 = static_cast< wxDataObject::Direction >(val2);
30862 }
30863 {
30864 PyThreadState* __tstate = wxPyBeginAllowThreads();
30865 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30870 return resultobj;
30871 fail:
30872 return NULL;
30873 }
30874
30875
30876 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30877 PyObject *resultobj = 0;
30878 wxDataObject *arg1 = (wxDataObject *) 0 ;
30879 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30880 size_t result;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 int val2 ;
30884 int ecode2 = 0 ;
30885 PyObject * obj0 = 0 ;
30886 PyObject * obj1 = 0 ;
30887 char * kwnames[] = {
30888 (char *) "self",(char *) "dir", NULL
30889 };
30890
30891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30893 if (!SWIG_IsOK(res1)) {
30894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30895 }
30896 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30897 if (obj1) {
30898 ecode2 = SWIG_AsVal_int(obj1, &val2);
30899 if (!SWIG_IsOK(ecode2)) {
30900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30901 }
30902 arg2 = static_cast< wxDataObject::Direction >(val2);
30903 }
30904 {
30905 PyThreadState* __tstate = wxPyBeginAllowThreads();
30906 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30907 wxPyEndAllowThreads(__tstate);
30908 if (PyErr_Occurred()) SWIG_fail;
30909 }
30910 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30911 return resultobj;
30912 fail:
30913 return NULL;
30914 }
30915
30916
30917 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30918 PyObject *resultobj = 0;
30919 wxDataObject *arg1 = (wxDataObject *) 0 ;
30920 wxDataFormat *arg2 = 0 ;
30921 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30922 bool result;
30923 void *argp1 = 0 ;
30924 int res1 = 0 ;
30925 void *argp2 = 0 ;
30926 int res2 = 0 ;
30927 int val3 ;
30928 int ecode3 = 0 ;
30929 PyObject * obj0 = 0 ;
30930 PyObject * obj1 = 0 ;
30931 PyObject * obj2 = 0 ;
30932 char * kwnames[] = {
30933 (char *) "self",(char *) "format",(char *) "dir", NULL
30934 };
30935
30936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30938 if (!SWIG_IsOK(res1)) {
30939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30940 }
30941 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30943 if (!SWIG_IsOK(res2)) {
30944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30945 }
30946 if (!argp2) {
30947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30948 }
30949 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30950 if (obj2) {
30951 ecode3 = SWIG_AsVal_int(obj2, &val3);
30952 if (!SWIG_IsOK(ecode3)) {
30953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30954 }
30955 arg3 = static_cast< wxDataObject::Direction >(val3);
30956 }
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30960 wxPyEndAllowThreads(__tstate);
30961 if (PyErr_Occurred()) SWIG_fail;
30962 }
30963 {
30964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30965 }
30966 return resultobj;
30967 fail:
30968 return NULL;
30969 }
30970
30971
30972 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30973 PyObject *resultobj = 0;
30974 wxDataObject *arg1 = (wxDataObject *) 0 ;
30975 wxDataFormat *arg2 = 0 ;
30976 size_t result;
30977 void *argp1 = 0 ;
30978 int res1 = 0 ;
30979 void *argp2 = 0 ;
30980 int res2 = 0 ;
30981 PyObject * obj0 = 0 ;
30982 PyObject * obj1 = 0 ;
30983 char * kwnames[] = {
30984 (char *) "self",(char *) "format", NULL
30985 };
30986
30987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30989 if (!SWIG_IsOK(res1)) {
30990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30991 }
30992 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30994 if (!SWIG_IsOK(res2)) {
30995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30996 }
30997 if (!argp2) {
30998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30999 }
31000 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31001 {
31002 PyThreadState* __tstate = wxPyBeginAllowThreads();
31003 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31015 PyObject *resultobj = 0;
31016 wxDataObject *arg1 = (wxDataObject *) 0 ;
31017 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31018 PyObject *result = 0 ;
31019 void *argp1 = 0 ;
31020 int res1 = 0 ;
31021 int val2 ;
31022 int ecode2 = 0 ;
31023 PyObject * obj0 = 0 ;
31024 PyObject * obj1 = 0 ;
31025 char * kwnames[] = {
31026 (char *) "self",(char *) "dir", NULL
31027 };
31028
31029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31031 if (!SWIG_IsOK(res1)) {
31032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31033 }
31034 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31035 if (obj1) {
31036 ecode2 = SWIG_AsVal_int(obj1, &val2);
31037 if (!SWIG_IsOK(ecode2)) {
31038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31039 }
31040 arg2 = static_cast< wxDataObject::Direction >(val2);
31041 }
31042 {
31043 PyThreadState* __tstate = wxPyBeginAllowThreads();
31044 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31045 wxPyEndAllowThreads(__tstate);
31046 if (PyErr_Occurred()) SWIG_fail;
31047 }
31048 resultobj = result;
31049 return resultobj;
31050 fail:
31051 return NULL;
31052 }
31053
31054
31055 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31056 PyObject *resultobj = 0;
31057 wxDataObject *arg1 = (wxDataObject *) 0 ;
31058 wxDataFormat *arg2 = 0 ;
31059 PyObject *result = 0 ;
31060 void *argp1 = 0 ;
31061 int res1 = 0 ;
31062 void *argp2 = 0 ;
31063 int res2 = 0 ;
31064 PyObject * obj0 = 0 ;
31065 PyObject * obj1 = 0 ;
31066 char * kwnames[] = {
31067 (char *) "self",(char *) "format", NULL
31068 };
31069
31070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
31071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31072 if (!SWIG_IsOK(res1)) {
31073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
31074 }
31075 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31076 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31077 if (!SWIG_IsOK(res2)) {
31078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31079 }
31080 if (!argp2) {
31081 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31082 }
31083 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31084 {
31085 PyThreadState* __tstate = wxPyBeginAllowThreads();
31086 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 resultobj = result;
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31098 PyObject *resultobj = 0;
31099 wxDataObject *arg1 = (wxDataObject *) 0 ;
31100 wxDataFormat *arg2 = 0 ;
31101 PyObject *arg3 = (PyObject *) 0 ;
31102 bool result;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 void *argp2 = 0 ;
31106 int res2 = 0 ;
31107 PyObject * obj0 = 0 ;
31108 PyObject * obj1 = 0 ;
31109 PyObject * obj2 = 0 ;
31110 char * kwnames[] = {
31111 (char *) "self",(char *) "format",(char *) "data", NULL
31112 };
31113
31114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31116 if (!SWIG_IsOK(res1)) {
31117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
31118 }
31119 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31120 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31121 if (!SWIG_IsOK(res2)) {
31122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31123 }
31124 if (!argp2) {
31125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31126 }
31127 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31128 arg3 = obj2;
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 {
31136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31137 }
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31145 PyObject *obj;
31146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31147 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31148 return SWIG_Py_Void();
31149 }
31150
31151 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31152 PyObject *resultobj = 0;
31153 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31154 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31155 wxDataObjectSimple *result = 0 ;
31156 void *argp1 = 0 ;
31157 int res1 = 0 ;
31158 PyObject * obj0 = 0 ;
31159 char * kwnames[] = {
31160 (char *) "format", NULL
31161 };
31162
31163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31164 if (obj0) {
31165 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31166 if (!SWIG_IsOK(res1)) {
31167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31168 }
31169 if (!argp1) {
31170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31171 }
31172 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31173 }
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31177 wxPyEndAllowThreads(__tstate);
31178 if (PyErr_Occurred()) SWIG_fail;
31179 }
31180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31181 return resultobj;
31182 fail:
31183 return NULL;
31184 }
31185
31186
31187 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31188 PyObject *resultobj = 0;
31189 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31190 wxDataFormat *result = 0 ;
31191 void *argp1 = 0 ;
31192 int res1 = 0 ;
31193 PyObject *swig_obj[1] ;
31194
31195 if (!args) SWIG_fail;
31196 swig_obj[0] = args;
31197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31198 if (!SWIG_IsOK(res1)) {
31199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31200 }
31201 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31202 {
31203 PyThreadState* __tstate = wxPyBeginAllowThreads();
31204 {
31205 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31206 result = (wxDataFormat *) &_result_ref;
31207 }
31208 wxPyEndAllowThreads(__tstate);
31209 if (PyErr_Occurred()) SWIG_fail;
31210 }
31211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31212 return resultobj;
31213 fail:
31214 return NULL;
31215 }
31216
31217
31218 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31219 PyObject *resultobj = 0;
31220 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31221 wxDataFormat *arg2 = 0 ;
31222 void *argp1 = 0 ;
31223 int res1 = 0 ;
31224 void *argp2 = 0 ;
31225 int res2 = 0 ;
31226 PyObject * obj0 = 0 ;
31227 PyObject * obj1 = 0 ;
31228 char * kwnames[] = {
31229 (char *) "self",(char *) "format", NULL
31230 };
31231
31232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31234 if (!SWIG_IsOK(res1)) {
31235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31236 }
31237 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31238 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31239 if (!SWIG_IsOK(res2)) {
31240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31241 }
31242 if (!argp2) {
31243 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31244 }
31245 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31246 {
31247 PyThreadState* __tstate = wxPyBeginAllowThreads();
31248 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31249 wxPyEndAllowThreads(__tstate);
31250 if (PyErr_Occurred()) SWIG_fail;
31251 }
31252 resultobj = SWIG_Py_Void();
31253 return resultobj;
31254 fail:
31255 return NULL;
31256 }
31257
31258
31259 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31260 PyObject *resultobj = 0;
31261 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31262 size_t result;
31263 void *argp1 = 0 ;
31264 int res1 = 0 ;
31265 PyObject *swig_obj[1] ;
31266
31267 if (!args) SWIG_fail;
31268 swig_obj[0] = args;
31269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31270 if (!SWIG_IsOK(res1)) {
31271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31272 }
31273 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31274 {
31275 PyThreadState* __tstate = wxPyBeginAllowThreads();
31276 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31288 PyObject *resultobj = 0;
31289 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31290 PyObject *result = 0 ;
31291 void *argp1 = 0 ;
31292 int res1 = 0 ;
31293 PyObject *swig_obj[1] ;
31294
31295 if (!args) SWIG_fail;
31296 swig_obj[0] = args;
31297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31298 if (!SWIG_IsOK(res1)) {
31299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31300 }
31301 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = result;
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj = 0;
31317 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31318 PyObject *arg2 = (PyObject *) 0 ;
31319 bool result;
31320 void *argp1 = 0 ;
31321 int res1 = 0 ;
31322 PyObject * obj0 = 0 ;
31323 PyObject * obj1 = 0 ;
31324 char * kwnames[] = {
31325 (char *) "self",(char *) "data", NULL
31326 };
31327
31328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31330 if (!SWIG_IsOK(res1)) {
31331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31332 }
31333 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31334 arg2 = obj1;
31335 {
31336 PyThreadState* __tstate = wxPyBeginAllowThreads();
31337 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 {
31342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31343 }
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31351 PyObject *obj;
31352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31353 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31354 return SWIG_Py_Void();
31355 }
31356
31357 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 return SWIG_Python_InitShadowInstance(args);
31359 }
31360
31361 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj = 0;
31363 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31364 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31365 wxPyDataObjectSimple *result = 0 ;
31366 void *argp1 = 0 ;
31367 int res1 = 0 ;
31368 PyObject * obj0 = 0 ;
31369 char * kwnames[] = {
31370 (char *) "format", NULL
31371 };
31372
31373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31374 if (obj0) {
31375 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31376 if (!SWIG_IsOK(res1)) {
31377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31378 }
31379 if (!argp1) {
31380 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31381 }
31382 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31383 }
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = 0;
31399 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31400 PyObject *arg2 = (PyObject *) 0 ;
31401 PyObject *arg3 = (PyObject *) 0 ;
31402 void *argp1 = 0 ;
31403 int res1 = 0 ;
31404 PyObject * obj0 = 0 ;
31405 PyObject * obj1 = 0 ;
31406 PyObject * obj2 = 0 ;
31407 char * kwnames[] = {
31408 (char *) "self",(char *) "self",(char *) "_class", NULL
31409 };
31410
31411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31413 if (!SWIG_IsOK(res1)) {
31414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31415 }
31416 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31417 arg2 = obj1;
31418 arg3 = obj2;
31419 {
31420 PyThreadState* __tstate = wxPyBeginAllowThreads();
31421 (arg1)->_setCallbackInfo(arg2,arg3);
31422 wxPyEndAllowThreads(__tstate);
31423 if (PyErr_Occurred()) SWIG_fail;
31424 }
31425 resultobj = SWIG_Py_Void();
31426 return resultobj;
31427 fail:
31428 return NULL;
31429 }
31430
31431
31432 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31433 PyObject *obj;
31434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31435 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31436 return SWIG_Py_Void();
31437 }
31438
31439 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31440 return SWIG_Python_InitShadowInstance(args);
31441 }
31442
31443 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31444 PyObject *resultobj = 0;
31445 wxDataObjectComposite *result = 0 ;
31446
31447 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31448 {
31449 PyThreadState* __tstate = wxPyBeginAllowThreads();
31450 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31451 wxPyEndAllowThreads(__tstate);
31452 if (PyErr_Occurred()) SWIG_fail;
31453 }
31454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31455 return resultobj;
31456 fail:
31457 return NULL;
31458 }
31459
31460
31461 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31462 PyObject *resultobj = 0;
31463 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31464 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31465 bool arg3 = (bool) false ;
31466 void *argp1 = 0 ;
31467 int res1 = 0 ;
31468 int res2 = 0 ;
31469 bool val3 ;
31470 int ecode3 = 0 ;
31471 PyObject * obj0 = 0 ;
31472 PyObject * obj1 = 0 ;
31473 PyObject * obj2 = 0 ;
31474 char * kwnames[] = {
31475 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31476 };
31477
31478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31480 if (!SWIG_IsOK(res1)) {
31481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31482 }
31483 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31484 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31485 if (!SWIG_IsOK(res2)) {
31486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31487 }
31488 if (obj2) {
31489 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31490 if (!SWIG_IsOK(ecode3)) {
31491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31492 }
31493 arg3 = static_cast< bool >(val3);
31494 }
31495 {
31496 PyThreadState* __tstate = wxPyBeginAllowThreads();
31497 (arg1)->Add(arg2,arg3);
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 resultobj = SWIG_Py_Void();
31502 return resultobj;
31503 fail:
31504 return NULL;
31505 }
31506
31507
31508 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31509 PyObject *resultobj = 0;
31510 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31511 SwigValueWrapper<wxDataFormat > result;
31512 void *argp1 = 0 ;
31513 int res1 = 0 ;
31514 PyObject *swig_obj[1] ;
31515
31516 if (!args) SWIG_fail;
31517 swig_obj[0] = args;
31518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31519 if (!SWIG_IsOK(res1)) {
31520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31521 }
31522 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31537 PyObject *obj;
31538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31539 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31540 return SWIG_Py_Void();
31541 }
31542
31543 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31544 return SWIG_Python_InitShadowInstance(args);
31545 }
31546
31547 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31548 PyObject *resultobj = 0;
31549 wxString const &arg1_defvalue = wxPyEmptyString ;
31550 wxString *arg1 = (wxString *) &arg1_defvalue ;
31551 wxTextDataObject *result = 0 ;
31552 bool temp1 = false ;
31553 PyObject * obj0 = 0 ;
31554 char * kwnames[] = {
31555 (char *) "text", NULL
31556 };
31557
31558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31559 if (obj0) {
31560 {
31561 arg1 = wxString_in_helper(obj0);
31562 if (arg1 == NULL) SWIG_fail;
31563 temp1 = true;
31564 }
31565 }
31566 {
31567 PyThreadState* __tstate = wxPyBeginAllowThreads();
31568 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31569 wxPyEndAllowThreads(__tstate);
31570 if (PyErr_Occurred()) SWIG_fail;
31571 }
31572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31573 {
31574 if (temp1)
31575 delete arg1;
31576 }
31577 return resultobj;
31578 fail:
31579 {
31580 if (temp1)
31581 delete arg1;
31582 }
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *resultobj = 0;
31589 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31590 size_t result;
31591 void *argp1 = 0 ;
31592 int res1 = 0 ;
31593 PyObject *swig_obj[1] ;
31594
31595 if (!args) SWIG_fail;
31596 swig_obj[0] = args;
31597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31598 if (!SWIG_IsOK(res1)) {
31599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31600 }
31601 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31602 {
31603 PyThreadState* __tstate = wxPyBeginAllowThreads();
31604 result = (size_t)(arg1)->GetTextLength();
31605 wxPyEndAllowThreads(__tstate);
31606 if (PyErr_Occurred()) SWIG_fail;
31607 }
31608 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31609 return resultobj;
31610 fail:
31611 return NULL;
31612 }
31613
31614
31615 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31616 PyObject *resultobj = 0;
31617 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31618 wxString result;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 PyObject *swig_obj[1] ;
31622
31623 if (!args) SWIG_fail;
31624 swig_obj[0] = args;
31625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31626 if (!SWIG_IsOK(res1)) {
31627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31628 }
31629 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31630 {
31631 PyThreadState* __tstate = wxPyBeginAllowThreads();
31632 result = (arg1)->GetText();
31633 wxPyEndAllowThreads(__tstate);
31634 if (PyErr_Occurred()) SWIG_fail;
31635 }
31636 {
31637 #if wxUSE_UNICODE
31638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31639 #else
31640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31641 #endif
31642 }
31643 return resultobj;
31644 fail:
31645 return NULL;
31646 }
31647
31648
31649 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31650 PyObject *resultobj = 0;
31651 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31652 wxString *arg2 = 0 ;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 bool temp2 = false ;
31656 PyObject * obj0 = 0 ;
31657 PyObject * obj1 = 0 ;
31658 char * kwnames[] = {
31659 (char *) "self",(char *) "text", NULL
31660 };
31661
31662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31664 if (!SWIG_IsOK(res1)) {
31665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31666 }
31667 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31668 {
31669 arg2 = wxString_in_helper(obj1);
31670 if (arg2 == NULL) SWIG_fail;
31671 temp2 = true;
31672 }
31673 {
31674 PyThreadState* __tstate = wxPyBeginAllowThreads();
31675 (arg1)->SetText((wxString const &)*arg2);
31676 wxPyEndAllowThreads(__tstate);
31677 if (PyErr_Occurred()) SWIG_fail;
31678 }
31679 resultobj = SWIG_Py_Void();
31680 {
31681 if (temp2)
31682 delete arg2;
31683 }
31684 return resultobj;
31685 fail:
31686 {
31687 if (temp2)
31688 delete arg2;
31689 }
31690 return NULL;
31691 }
31692
31693
31694 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31695 PyObject *obj;
31696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31697 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31698 return SWIG_Py_Void();
31699 }
31700
31701 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31702 return SWIG_Python_InitShadowInstance(args);
31703 }
31704
31705 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31706 PyObject *resultobj = 0;
31707 wxString const &arg1_defvalue = wxPyEmptyString ;
31708 wxString *arg1 = (wxString *) &arg1_defvalue ;
31709 wxPyTextDataObject *result = 0 ;
31710 bool temp1 = false ;
31711 PyObject * obj0 = 0 ;
31712 char * kwnames[] = {
31713 (char *) "text", NULL
31714 };
31715
31716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31717 if (obj0) {
31718 {
31719 arg1 = wxString_in_helper(obj0);
31720 if (arg1 == NULL) SWIG_fail;
31721 temp1 = true;
31722 }
31723 }
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31731 {
31732 if (temp1)
31733 delete arg1;
31734 }
31735 return resultobj;
31736 fail:
31737 {
31738 if (temp1)
31739 delete arg1;
31740 }
31741 return NULL;
31742 }
31743
31744
31745 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31746 PyObject *resultobj = 0;
31747 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31748 PyObject *arg2 = (PyObject *) 0 ;
31749 PyObject *arg3 = (PyObject *) 0 ;
31750 void *argp1 = 0 ;
31751 int res1 = 0 ;
31752 PyObject * obj0 = 0 ;
31753 PyObject * obj1 = 0 ;
31754 PyObject * obj2 = 0 ;
31755 char * kwnames[] = {
31756 (char *) "self",(char *) "self",(char *) "_class", NULL
31757 };
31758
31759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31763 }
31764 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31765 arg2 = obj1;
31766 arg3 = obj2;
31767 {
31768 PyThreadState* __tstate = wxPyBeginAllowThreads();
31769 (arg1)->_setCallbackInfo(arg2,arg3);
31770 wxPyEndAllowThreads(__tstate);
31771 if (PyErr_Occurred()) SWIG_fail;
31772 }
31773 resultobj = SWIG_Py_Void();
31774 return resultobj;
31775 fail:
31776 return NULL;
31777 }
31778
31779
31780 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31781 PyObject *obj;
31782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31783 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31784 return SWIG_Py_Void();
31785 }
31786
31787 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31788 return SWIG_Python_InitShadowInstance(args);
31789 }
31790
31791 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31792 PyObject *resultobj = 0;
31793 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31794 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31795 wxBitmapDataObject *result = 0 ;
31796 void *argp1 = 0 ;
31797 int res1 = 0 ;
31798 PyObject * obj0 = 0 ;
31799 char * kwnames[] = {
31800 (char *) "bitmap", NULL
31801 };
31802
31803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31804 if (obj0) {
31805 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31808 }
31809 if (!argp1) {
31810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31811 }
31812 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31813 }
31814 {
31815 PyThreadState* __tstate = wxPyBeginAllowThreads();
31816 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31817 wxPyEndAllowThreads(__tstate);
31818 if (PyErr_Occurred()) SWIG_fail;
31819 }
31820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31828 PyObject *resultobj = 0;
31829 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31830 wxBitmap result;
31831 void *argp1 = 0 ;
31832 int res1 = 0 ;
31833 PyObject *swig_obj[1] ;
31834
31835 if (!args) SWIG_fail;
31836 swig_obj[0] = args;
31837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31838 if (!SWIG_IsOK(res1)) {
31839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31840 }
31841 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31842 {
31843 PyThreadState* __tstate = wxPyBeginAllowThreads();
31844 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31845 wxPyEndAllowThreads(__tstate);
31846 if (PyErr_Occurred()) SWIG_fail;
31847 }
31848 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31856 PyObject *resultobj = 0;
31857 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31858 wxBitmap *arg2 = 0 ;
31859 void *argp1 = 0 ;
31860 int res1 = 0 ;
31861 void *argp2 = 0 ;
31862 int res2 = 0 ;
31863 PyObject * obj0 = 0 ;
31864 PyObject * obj1 = 0 ;
31865 char * kwnames[] = {
31866 (char *) "self",(char *) "bitmap", NULL
31867 };
31868
31869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31871 if (!SWIG_IsOK(res1)) {
31872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31873 }
31874 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31875 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31876 if (!SWIG_IsOK(res2)) {
31877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31878 }
31879 if (!argp2) {
31880 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31881 }
31882 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 resultobj = SWIG_Py_Void();
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31897 PyObject *obj;
31898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31899 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31900 return SWIG_Py_Void();
31901 }
31902
31903 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31904 return SWIG_Python_InitShadowInstance(args);
31905 }
31906
31907 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31908 PyObject *resultobj = 0;
31909 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31910 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31911 wxPyBitmapDataObject *result = 0 ;
31912 void *argp1 = 0 ;
31913 int res1 = 0 ;
31914 PyObject * obj0 = 0 ;
31915 char * kwnames[] = {
31916 (char *) "bitmap", NULL
31917 };
31918
31919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31920 if (obj0) {
31921 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31922 if (!SWIG_IsOK(res1)) {
31923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31924 }
31925 if (!argp1) {
31926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31927 }
31928 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31929 }
31930 {
31931 PyThreadState* __tstate = wxPyBeginAllowThreads();
31932 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31933 wxPyEndAllowThreads(__tstate);
31934 if (PyErr_Occurred()) SWIG_fail;
31935 }
31936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31937 return resultobj;
31938 fail:
31939 return NULL;
31940 }
31941
31942
31943 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31944 PyObject *resultobj = 0;
31945 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31946 PyObject *arg2 = (PyObject *) 0 ;
31947 PyObject *arg3 = (PyObject *) 0 ;
31948 void *argp1 = 0 ;
31949 int res1 = 0 ;
31950 PyObject * obj0 = 0 ;
31951 PyObject * obj1 = 0 ;
31952 PyObject * obj2 = 0 ;
31953 char * kwnames[] = {
31954 (char *) "self",(char *) "self",(char *) "_class", NULL
31955 };
31956
31957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31959 if (!SWIG_IsOK(res1)) {
31960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31961 }
31962 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31963 arg2 = obj1;
31964 arg3 = obj2;
31965 {
31966 PyThreadState* __tstate = wxPyBeginAllowThreads();
31967 (arg1)->_setCallbackInfo(arg2,arg3);
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 resultobj = SWIG_Py_Void();
31972 return resultobj;
31973 fail:
31974 return NULL;
31975 }
31976
31977
31978 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31979 PyObject *obj;
31980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31981 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31982 return SWIG_Py_Void();
31983 }
31984
31985 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31986 return SWIG_Python_InitShadowInstance(args);
31987 }
31988
31989 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31990 PyObject *resultobj = 0;
31991 wxFileDataObject *result = 0 ;
31992
31993 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (wxFileDataObject *)new wxFileDataObject();
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32001 return resultobj;
32002 fail:
32003 return NULL;
32004 }
32005
32006
32007 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32008 PyObject *resultobj = 0;
32009 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32010 wxArrayString *result = 0 ;
32011 void *argp1 = 0 ;
32012 int res1 = 0 ;
32013 PyObject *swig_obj[1] ;
32014
32015 if (!args) SWIG_fail;
32016 swig_obj[0] = args;
32017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32018 if (!SWIG_IsOK(res1)) {
32019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32020 }
32021 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32022 {
32023 PyThreadState* __tstate = wxPyBeginAllowThreads();
32024 {
32025 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32026 result = (wxArrayString *) &_result_ref;
32027 }
32028 wxPyEndAllowThreads(__tstate);
32029 if (PyErr_Occurred()) SWIG_fail;
32030 }
32031 {
32032 resultobj = wxArrayString2PyList_helper(*result);
32033 }
32034 return resultobj;
32035 fail:
32036 return NULL;
32037 }
32038
32039
32040 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32041 PyObject *resultobj = 0;
32042 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32043 wxString *arg2 = 0 ;
32044 void *argp1 = 0 ;
32045 int res1 = 0 ;
32046 bool temp2 = false ;
32047 PyObject * obj0 = 0 ;
32048 PyObject * obj1 = 0 ;
32049 char * kwnames[] = {
32050 (char *) "self",(char *) "filename", NULL
32051 };
32052
32053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
32054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32055 if (!SWIG_IsOK(res1)) {
32056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32057 }
32058 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32059 {
32060 arg2 = wxString_in_helper(obj1);
32061 if (arg2 == NULL) SWIG_fail;
32062 temp2 = true;
32063 }
32064 {
32065 PyThreadState* __tstate = wxPyBeginAllowThreads();
32066 (arg1)->AddFile((wxString const &)*arg2);
32067 wxPyEndAllowThreads(__tstate);
32068 if (PyErr_Occurred()) SWIG_fail;
32069 }
32070 resultobj = SWIG_Py_Void();
32071 {
32072 if (temp2)
32073 delete arg2;
32074 }
32075 return resultobj;
32076 fail:
32077 {
32078 if (temp2)
32079 delete arg2;
32080 }
32081 return NULL;
32082 }
32083
32084
32085 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32086 PyObject *obj;
32087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32088 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
32089 return SWIG_Py_Void();
32090 }
32091
32092 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32093 return SWIG_Python_InitShadowInstance(args);
32094 }
32095
32096 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32097 PyObject *resultobj = 0;
32098 wxDataFormat *arg1 = 0 ;
32099 wxCustomDataObject *result = 0 ;
32100 void *argp1 = 0 ;
32101 int res1 = 0 ;
32102
32103 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32105 if (!SWIG_IsOK(res1)) {
32106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32107 }
32108 if (!argp1) {
32109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32110 }
32111 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32112 {
32113 PyThreadState* __tstate = wxPyBeginAllowThreads();
32114 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
32115 wxPyEndAllowThreads(__tstate);
32116 if (PyErr_Occurred()) SWIG_fail;
32117 }
32118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32119 return resultobj;
32120 fail:
32121 return NULL;
32122 }
32123
32124
32125 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32126 PyObject *resultobj = 0;
32127 wxString *arg1 = 0 ;
32128 wxCustomDataObject *result = 0 ;
32129 bool temp1 = false ;
32130
32131 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32132 {
32133 arg1 = wxString_in_helper(swig_obj[0]);
32134 if (arg1 == NULL) SWIG_fail;
32135 temp1 = true;
32136 }
32137 {
32138 PyThreadState* __tstate = wxPyBeginAllowThreads();
32139 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32140 wxPyEndAllowThreads(__tstate);
32141 if (PyErr_Occurred()) SWIG_fail;
32142 }
32143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32144 {
32145 if (temp1)
32146 delete arg1;
32147 }
32148 return resultobj;
32149 fail:
32150 {
32151 if (temp1)
32152 delete arg1;
32153 }
32154 return NULL;
32155 }
32156
32157
32158 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32159 PyObject *resultobj = 0;
32160 wxCustomDataObject *result = 0 ;
32161
32162 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32163 {
32164 PyThreadState* __tstate = wxPyBeginAllowThreads();
32165 result = (wxCustomDataObject *)new wxCustomDataObject();
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32177 int argc;
32178 PyObject *argv[2];
32179
32180 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32181 --argc;
32182 if (argc == 0) {
32183 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32184 }
32185 if (argc == 1) {
32186 int _v = 0;
32187 {
32188 {
32189 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32190 }
32191 }
32192 if (!_v) goto check_2;
32193 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32194 }
32195 check_2:
32196
32197 if (argc == 1) {
32198 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32199 }
32200
32201 fail:
32202 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32208 PyObject *resultobj = 0;
32209 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32210 PyObject *arg2 = (PyObject *) 0 ;
32211 bool result;
32212 void *argp1 = 0 ;
32213 int res1 = 0 ;
32214 PyObject * obj0 = 0 ;
32215 PyObject * obj1 = 0 ;
32216 char * kwnames[] = {
32217 (char *) "self",(char *) "data", NULL
32218 };
32219
32220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32222 if (!SWIG_IsOK(res1)) {
32223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32224 }
32225 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32226 arg2 = obj1;
32227 {
32228 PyThreadState* __tstate = wxPyBeginAllowThreads();
32229 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32230 wxPyEndAllowThreads(__tstate);
32231 if (PyErr_Occurred()) SWIG_fail;
32232 }
32233 {
32234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32235 }
32236 return resultobj;
32237 fail:
32238 return NULL;
32239 }
32240
32241
32242 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32243 PyObject *resultobj = 0;
32244 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32245 size_t result;
32246 void *argp1 = 0 ;
32247 int res1 = 0 ;
32248 PyObject *swig_obj[1] ;
32249
32250 if (!args) SWIG_fail;
32251 swig_obj[0] = args;
32252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32253 if (!SWIG_IsOK(res1)) {
32254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32255 }
32256 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32257 {
32258 PyThreadState* __tstate = wxPyBeginAllowThreads();
32259 result = (size_t)(arg1)->GetSize();
32260 wxPyEndAllowThreads(__tstate);
32261 if (PyErr_Occurred()) SWIG_fail;
32262 }
32263 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32264 return resultobj;
32265 fail:
32266 return NULL;
32267 }
32268
32269
32270 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32271 PyObject *resultobj = 0;
32272 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32273 PyObject *result = 0 ;
32274 void *argp1 = 0 ;
32275 int res1 = 0 ;
32276 PyObject *swig_obj[1] ;
32277
32278 if (!args) SWIG_fail;
32279 swig_obj[0] = args;
32280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32281 if (!SWIG_IsOK(res1)) {
32282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32283 }
32284 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32285 {
32286 PyThreadState* __tstate = wxPyBeginAllowThreads();
32287 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 resultobj = result;
32292 return resultobj;
32293 fail:
32294 return NULL;
32295 }
32296
32297
32298 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32299 PyObject *obj;
32300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32301 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32302 return SWIG_Py_Void();
32303 }
32304
32305 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32306 return SWIG_Python_InitShadowInstance(args);
32307 }
32308
32309 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32310 PyObject *resultobj = 0;
32311 wxURLDataObject *result = 0 ;
32312
32313 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 result = (wxURLDataObject *)new wxURLDataObject();
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32328 PyObject *resultobj = 0;
32329 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32330 wxString result;
32331 void *argp1 = 0 ;
32332 int res1 = 0 ;
32333 PyObject *swig_obj[1] ;
32334
32335 if (!args) SWIG_fail;
32336 swig_obj[0] = args;
32337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32338 if (!SWIG_IsOK(res1)) {
32339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32340 }
32341 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 result = (arg1)->GetURL();
32345 wxPyEndAllowThreads(__tstate);
32346 if (PyErr_Occurred()) SWIG_fail;
32347 }
32348 {
32349 #if wxUSE_UNICODE
32350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32351 #else
32352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32353 #endif
32354 }
32355 return resultobj;
32356 fail:
32357 return NULL;
32358 }
32359
32360
32361 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32362 PyObject *resultobj = 0;
32363 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32364 wxString *arg2 = 0 ;
32365 void *argp1 = 0 ;
32366 int res1 = 0 ;
32367 bool temp2 = false ;
32368 PyObject * obj0 = 0 ;
32369 PyObject * obj1 = 0 ;
32370 char * kwnames[] = {
32371 (char *) "self",(char *) "url", NULL
32372 };
32373
32374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32376 if (!SWIG_IsOK(res1)) {
32377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32378 }
32379 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32380 {
32381 arg2 = wxString_in_helper(obj1);
32382 if (arg2 == NULL) SWIG_fail;
32383 temp2 = true;
32384 }
32385 {
32386 PyThreadState* __tstate = wxPyBeginAllowThreads();
32387 (arg1)->SetURL((wxString const &)*arg2);
32388 wxPyEndAllowThreads(__tstate);
32389 if (PyErr_Occurred()) SWIG_fail;
32390 }
32391 resultobj = SWIG_Py_Void();
32392 {
32393 if (temp2)
32394 delete arg2;
32395 }
32396 return resultobj;
32397 fail:
32398 {
32399 if (temp2)
32400 delete arg2;
32401 }
32402 return NULL;
32403 }
32404
32405
32406 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32407 PyObject *obj;
32408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32409 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32410 return SWIG_Py_Void();
32411 }
32412
32413 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32414 return SWIG_Python_InitShadowInstance(args);
32415 }
32416
32417 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32418 PyObject *resultobj = 0;
32419 wxMetafileDataObject *result = 0 ;
32420
32421 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32422 {
32423 PyThreadState* __tstate = wxPyBeginAllowThreads();
32424 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32425 wxPyEndAllowThreads(__tstate);
32426 if (PyErr_Occurred()) SWIG_fail;
32427 }
32428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32429 return resultobj;
32430 fail:
32431 return NULL;
32432 }
32433
32434
32435 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32436 PyObject *resultobj = 0;
32437 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32438 wxMetafile *arg2 = 0 ;
32439 void *argp1 = 0 ;
32440 int res1 = 0 ;
32441 void *argp2 = 0 ;
32442 int res2 = 0 ;
32443 PyObject * obj0 = 0 ;
32444 PyObject * obj1 = 0 ;
32445 char * kwnames[] = {
32446 (char *) "self",(char *) "metafile", NULL
32447 };
32448
32449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32451 if (!SWIG_IsOK(res1)) {
32452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32453 }
32454 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32455 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32456 if (!SWIG_IsOK(res2)) {
32457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32458 }
32459 if (!argp2) {
32460 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32461 }
32462 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32463 {
32464 PyThreadState* __tstate = wxPyBeginAllowThreads();
32465 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32466 wxPyEndAllowThreads(__tstate);
32467 if (PyErr_Occurred()) SWIG_fail;
32468 }
32469 resultobj = SWIG_Py_Void();
32470 return resultobj;
32471 fail:
32472 return NULL;
32473 }
32474
32475
32476 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32477 PyObject *resultobj = 0;
32478 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32479 wxMetafile result;
32480 void *argp1 = 0 ;
32481 int res1 = 0 ;
32482 PyObject *swig_obj[1] ;
32483
32484 if (!args) SWIG_fail;
32485 swig_obj[0] = args;
32486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32487 if (!SWIG_IsOK(res1)) {
32488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32489 }
32490 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32491 {
32492 PyThreadState* __tstate = wxPyBeginAllowThreads();
32493 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32494 wxPyEndAllowThreads(__tstate);
32495 if (PyErr_Occurred()) SWIG_fail;
32496 }
32497 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32498 return resultobj;
32499 fail:
32500 return NULL;
32501 }
32502
32503
32504 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32505 PyObject *obj;
32506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32507 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32508 return SWIG_Py_Void();
32509 }
32510
32511 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32512 return SWIG_Python_InitShadowInstance(args);
32513 }
32514
32515 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32516 PyObject *resultobj = 0;
32517 wxDragResult arg1 ;
32518 bool result;
32519 int val1 ;
32520 int ecode1 = 0 ;
32521 PyObject * obj0 = 0 ;
32522 char * kwnames[] = {
32523 (char *) "res", NULL
32524 };
32525
32526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32527 ecode1 = SWIG_AsVal_int(obj0, &val1);
32528 if (!SWIG_IsOK(ecode1)) {
32529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32530 }
32531 arg1 = static_cast< wxDragResult >(val1);
32532 {
32533 PyThreadState* __tstate = wxPyBeginAllowThreads();
32534 result = (bool)wxIsDragResultOk(arg1);
32535 wxPyEndAllowThreads(__tstate);
32536 if (PyErr_Occurred()) SWIG_fail;
32537 }
32538 {
32539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32540 }
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32548 PyObject *resultobj = 0;
32549 wxWindow *arg1 = (wxWindow *) 0 ;
32550 wxCursor const &arg2_defvalue = wxNullCursor ;
32551 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32552 wxCursor const &arg3_defvalue = wxNullCursor ;
32553 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32554 wxCursor const &arg4_defvalue = wxNullCursor ;
32555 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32556 wxPyDropSource *result = 0 ;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 void *argp2 = 0 ;
32560 int res2 = 0 ;
32561 void *argp3 = 0 ;
32562 int res3 = 0 ;
32563 void *argp4 = 0 ;
32564 int res4 = 0 ;
32565 PyObject * obj0 = 0 ;
32566 PyObject * obj1 = 0 ;
32567 PyObject * obj2 = 0 ;
32568 PyObject * obj3 = 0 ;
32569 char * kwnames[] = {
32570 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32571 };
32572
32573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32575 if (!SWIG_IsOK(res1)) {
32576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32577 }
32578 arg1 = reinterpret_cast< wxWindow * >(argp1);
32579 if (obj1) {
32580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32581 if (!SWIG_IsOK(res2)) {
32582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32583 }
32584 if (!argp2) {
32585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32586 }
32587 arg2 = reinterpret_cast< wxCursor * >(argp2);
32588 }
32589 if (obj2) {
32590 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32591 if (!SWIG_IsOK(res3)) {
32592 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32593 }
32594 if (!argp3) {
32595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32596 }
32597 arg3 = reinterpret_cast< wxCursor * >(argp3);
32598 }
32599 if (obj3) {
32600 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32601 if (!SWIG_IsOK(res4)) {
32602 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32603 }
32604 if (!argp4) {
32605 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32606 }
32607 arg4 = reinterpret_cast< wxCursor * >(argp4);
32608 }
32609 {
32610 PyThreadState* __tstate = wxPyBeginAllowThreads();
32611 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32612 wxPyEndAllowThreads(__tstate);
32613 if (PyErr_Occurred()) SWIG_fail;
32614 }
32615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32616 return resultobj;
32617 fail:
32618 return NULL;
32619 }
32620
32621
32622 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32623 PyObject *resultobj = 0;
32624 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32625 PyObject *arg2 = (PyObject *) 0 ;
32626 PyObject *arg3 = (PyObject *) 0 ;
32627 int arg4 ;
32628 void *argp1 = 0 ;
32629 int res1 = 0 ;
32630 int val4 ;
32631 int ecode4 = 0 ;
32632 PyObject * obj0 = 0 ;
32633 PyObject * obj1 = 0 ;
32634 PyObject * obj2 = 0 ;
32635 PyObject * obj3 = 0 ;
32636 char * kwnames[] = {
32637 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32638 };
32639
32640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32642 if (!SWIG_IsOK(res1)) {
32643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32644 }
32645 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32646 arg2 = obj1;
32647 arg3 = obj2;
32648 ecode4 = SWIG_AsVal_int(obj3, &val4);
32649 if (!SWIG_IsOK(ecode4)) {
32650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32651 }
32652 arg4 = static_cast< int >(val4);
32653 {
32654 PyThreadState* __tstate = wxPyBeginAllowThreads();
32655 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32656 wxPyEndAllowThreads(__tstate);
32657 if (PyErr_Occurred()) SWIG_fail;
32658 }
32659 resultobj = SWIG_Py_Void();
32660 return resultobj;
32661 fail:
32662 return NULL;
32663 }
32664
32665
32666 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32667 PyObject *resultobj = 0;
32668 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32669 void *argp1 = 0 ;
32670 int res1 = 0 ;
32671 PyObject *swig_obj[1] ;
32672
32673 if (!args) SWIG_fail;
32674 swig_obj[0] = args;
32675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32676 if (!SWIG_IsOK(res1)) {
32677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32678 }
32679 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32680 {
32681 PyThreadState* __tstate = wxPyBeginAllowThreads();
32682 delete arg1;
32683
32684 wxPyEndAllowThreads(__tstate);
32685 if (PyErr_Occurred()) SWIG_fail;
32686 }
32687 resultobj = SWIG_Py_Void();
32688 return resultobj;
32689 fail:
32690 return NULL;
32691 }
32692
32693
32694 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32695 PyObject *resultobj = 0;
32696 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32697 wxDataObject *arg2 = 0 ;
32698 void *argp1 = 0 ;
32699 int res1 = 0 ;
32700 void *argp2 = 0 ;
32701 int res2 = 0 ;
32702 PyObject * obj0 = 0 ;
32703 PyObject * obj1 = 0 ;
32704 char * kwnames[] = {
32705 (char *) "self",(char *) "data", NULL
32706 };
32707
32708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32710 if (!SWIG_IsOK(res1)) {
32711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32712 }
32713 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32714 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32715 if (!SWIG_IsOK(res2)) {
32716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32717 }
32718 if (!argp2) {
32719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32720 }
32721 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32722 {
32723 PyThreadState* __tstate = wxPyBeginAllowThreads();
32724 (arg1)->SetData(*arg2);
32725 wxPyEndAllowThreads(__tstate);
32726 if (PyErr_Occurred()) SWIG_fail;
32727 }
32728 resultobj = SWIG_Py_Void();
32729 return resultobj;
32730 fail:
32731 return NULL;
32732 }
32733
32734
32735 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32736 PyObject *resultobj = 0;
32737 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32738 wxDataObject *result = 0 ;
32739 void *argp1 = 0 ;
32740 int res1 = 0 ;
32741 PyObject *swig_obj[1] ;
32742
32743 if (!args) SWIG_fail;
32744 swig_obj[0] = args;
32745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32746 if (!SWIG_IsOK(res1)) {
32747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32748 }
32749 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 result = (wxDataObject *)(arg1)->GetDataObject();
32753 wxPyEndAllowThreads(__tstate);
32754 if (PyErr_Occurred()) SWIG_fail;
32755 }
32756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32757 return resultobj;
32758 fail:
32759 return NULL;
32760 }
32761
32762
32763 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32764 PyObject *resultobj = 0;
32765 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32766 wxDragResult arg2 ;
32767 wxCursor *arg3 = 0 ;
32768 void *argp1 = 0 ;
32769 int res1 = 0 ;
32770 int val2 ;
32771 int ecode2 = 0 ;
32772 void *argp3 = 0 ;
32773 int res3 = 0 ;
32774 PyObject * obj0 = 0 ;
32775 PyObject * obj1 = 0 ;
32776 PyObject * obj2 = 0 ;
32777 char * kwnames[] = {
32778 (char *) "self",(char *) "res",(char *) "cursor", NULL
32779 };
32780
32781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32783 if (!SWIG_IsOK(res1)) {
32784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32785 }
32786 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32787 ecode2 = SWIG_AsVal_int(obj1, &val2);
32788 if (!SWIG_IsOK(ecode2)) {
32789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32790 }
32791 arg2 = static_cast< wxDragResult >(val2);
32792 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32793 if (!SWIG_IsOK(res3)) {
32794 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32795 }
32796 if (!argp3) {
32797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32798 }
32799 arg3 = reinterpret_cast< wxCursor * >(argp3);
32800 {
32801 PyThreadState* __tstate = wxPyBeginAllowThreads();
32802 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32803 wxPyEndAllowThreads(__tstate);
32804 if (PyErr_Occurred()) SWIG_fail;
32805 }
32806 resultobj = SWIG_Py_Void();
32807 return resultobj;
32808 fail:
32809 return NULL;
32810 }
32811
32812
32813 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32814 PyObject *resultobj = 0;
32815 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32816 int arg2 = (int) wxDrag_CopyOnly ;
32817 wxDragResult result;
32818 void *argp1 = 0 ;
32819 int res1 = 0 ;
32820 int val2 ;
32821 int ecode2 = 0 ;
32822 PyObject * obj0 = 0 ;
32823 PyObject * obj1 = 0 ;
32824 char * kwnames[] = {
32825 (char *) "self",(char *) "flags", NULL
32826 };
32827
32828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32830 if (!SWIG_IsOK(res1)) {
32831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32832 }
32833 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32834 if (obj1) {
32835 ecode2 = SWIG_AsVal_int(obj1, &val2);
32836 if (!SWIG_IsOK(ecode2)) {
32837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32838 }
32839 arg2 = static_cast< int >(val2);
32840 }
32841 {
32842 PyThreadState* __tstate = wxPyBeginAllowThreads();
32843 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32844 wxPyEndAllowThreads(__tstate);
32845 if (PyErr_Occurred()) SWIG_fail;
32846 }
32847 resultobj = SWIG_From_int(static_cast< int >(result));
32848 return resultobj;
32849 fail:
32850 return NULL;
32851 }
32852
32853
32854 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32855 PyObject *resultobj = 0;
32856 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32857 wxDragResult arg2 ;
32858 bool result;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 int val2 ;
32862 int ecode2 = 0 ;
32863 PyObject * obj0 = 0 ;
32864 PyObject * obj1 = 0 ;
32865 char * kwnames[] = {
32866 (char *) "self",(char *) "effect", NULL
32867 };
32868
32869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32871 if (!SWIG_IsOK(res1)) {
32872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32873 }
32874 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32875 ecode2 = SWIG_AsVal_int(obj1, &val2);
32876 if (!SWIG_IsOK(ecode2)) {
32877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32878 }
32879 arg2 = static_cast< wxDragResult >(val2);
32880 {
32881 PyThreadState* __tstate = wxPyBeginAllowThreads();
32882 result = (bool)(arg1)->GiveFeedback(arg2);
32883 wxPyEndAllowThreads(__tstate);
32884 if (PyErr_Occurred()) SWIG_fail;
32885 }
32886 {
32887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32888 }
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32896 PyObject *obj;
32897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32898 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32899 return SWIG_Py_Void();
32900 }
32901
32902 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32903 return SWIG_Python_InitShadowInstance(args);
32904 }
32905
32906 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32907 PyObject *resultobj = 0;
32908 wxDataObject *arg1 = (wxDataObject *) NULL ;
32909 wxPyDropTarget *result = 0 ;
32910 int res1 = 0 ;
32911 PyObject * obj0 = 0 ;
32912 char * kwnames[] = {
32913 (char *) "dataObject", NULL
32914 };
32915
32916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32917 if (obj0) {
32918 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32919 if (!SWIG_IsOK(res1)) {
32920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32921 }
32922 }
32923 {
32924 PyThreadState* __tstate = wxPyBeginAllowThreads();
32925 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32930 return resultobj;
32931 fail:
32932 return NULL;
32933 }
32934
32935
32936 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32937 PyObject *resultobj = 0;
32938 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32939 PyObject *arg2 = (PyObject *) 0 ;
32940 PyObject *arg3 = (PyObject *) 0 ;
32941 void *argp1 = 0 ;
32942 int res1 = 0 ;
32943 PyObject * obj0 = 0 ;
32944 PyObject * obj1 = 0 ;
32945 PyObject * obj2 = 0 ;
32946 char * kwnames[] = {
32947 (char *) "self",(char *) "self",(char *) "_class", NULL
32948 };
32949
32950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32952 if (!SWIG_IsOK(res1)) {
32953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32954 }
32955 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32956 arg2 = obj1;
32957 arg3 = obj2;
32958 {
32959 PyThreadState* __tstate = wxPyBeginAllowThreads();
32960 (arg1)->_setCallbackInfo(arg2,arg3);
32961 wxPyEndAllowThreads(__tstate);
32962 if (PyErr_Occurred()) SWIG_fail;
32963 }
32964 resultobj = SWIG_Py_Void();
32965 return resultobj;
32966 fail:
32967 return NULL;
32968 }
32969
32970
32971 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32972 PyObject *resultobj = 0;
32973 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32974 void *argp1 = 0 ;
32975 int res1 = 0 ;
32976 PyObject *swig_obj[1] ;
32977
32978 if (!args) SWIG_fail;
32979 swig_obj[0] = args;
32980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32981 if (!SWIG_IsOK(res1)) {
32982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32983 }
32984 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32985 {
32986 PyThreadState* __tstate = wxPyBeginAllowThreads();
32987 delete arg1;
32988
32989 wxPyEndAllowThreads(__tstate);
32990 if (PyErr_Occurred()) SWIG_fail;
32991 }
32992 resultobj = SWIG_Py_Void();
32993 return resultobj;
32994 fail:
32995 return NULL;
32996 }
32997
32998
32999 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33000 PyObject *resultobj = 0;
33001 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33002 wxDataObject *result = 0 ;
33003 void *argp1 = 0 ;
33004 int res1 = 0 ;
33005 PyObject *swig_obj[1] ;
33006
33007 if (!args) SWIG_fail;
33008 swig_obj[0] = args;
33009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33010 if (!SWIG_IsOK(res1)) {
33011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33012 }
33013 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33014 {
33015 PyThreadState* __tstate = wxPyBeginAllowThreads();
33016 result = (wxDataObject *)(arg1)->GetDataObject();
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33021 return resultobj;
33022 fail:
33023 return NULL;
33024 }
33025
33026
33027 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33028 PyObject *resultobj = 0;
33029 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33030 wxDataObject *arg2 = (wxDataObject *) 0 ;
33031 void *argp1 = 0 ;
33032 int res1 = 0 ;
33033 int res2 = 0 ;
33034 PyObject * obj0 = 0 ;
33035 PyObject * obj1 = 0 ;
33036 char * kwnames[] = {
33037 (char *) "self",(char *) "dataObject", NULL
33038 };
33039
33040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
33041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33042 if (!SWIG_IsOK(res1)) {
33043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33044 }
33045 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33046 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33047 if (!SWIG_IsOK(res2)) {
33048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
33049 }
33050 {
33051 PyThreadState* __tstate = wxPyBeginAllowThreads();
33052 (arg1)->SetDataObject(arg2);
33053 wxPyEndAllowThreads(__tstate);
33054 if (PyErr_Occurred()) SWIG_fail;
33055 }
33056 resultobj = SWIG_Py_Void();
33057 return resultobj;
33058 fail:
33059 return NULL;
33060 }
33061
33062
33063 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33064 PyObject *resultobj = 0;
33065 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33066 int arg2 ;
33067 int arg3 ;
33068 wxDragResult arg4 ;
33069 wxDragResult result;
33070 void *argp1 = 0 ;
33071 int res1 = 0 ;
33072 int val2 ;
33073 int ecode2 = 0 ;
33074 int val3 ;
33075 int ecode3 = 0 ;
33076 int val4 ;
33077 int ecode4 = 0 ;
33078 PyObject * obj0 = 0 ;
33079 PyObject * obj1 = 0 ;
33080 PyObject * obj2 = 0 ;
33081 PyObject * obj3 = 0 ;
33082 char * kwnames[] = {
33083 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33084 };
33085
33086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33088 if (!SWIG_IsOK(res1)) {
33089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33090 }
33091 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33092 ecode2 = SWIG_AsVal_int(obj1, &val2);
33093 if (!SWIG_IsOK(ecode2)) {
33094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33095 }
33096 arg2 = static_cast< int >(val2);
33097 ecode3 = SWIG_AsVal_int(obj2, &val3);
33098 if (!SWIG_IsOK(ecode3)) {
33099 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33100 }
33101 arg3 = static_cast< int >(val3);
33102 ecode4 = SWIG_AsVal_int(obj3, &val4);
33103 if (!SWIG_IsOK(ecode4)) {
33104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33105 }
33106 arg4 = static_cast< wxDragResult >(val4);
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 resultobj = SWIG_From_int(static_cast< int >(result));
33114 return resultobj;
33115 fail:
33116 return NULL;
33117 }
33118
33119
33120 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33121 PyObject *resultobj = 0;
33122 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33123 int arg2 ;
33124 int arg3 ;
33125 wxDragResult arg4 ;
33126 wxDragResult result;
33127 void *argp1 = 0 ;
33128 int res1 = 0 ;
33129 int val2 ;
33130 int ecode2 = 0 ;
33131 int val3 ;
33132 int ecode3 = 0 ;
33133 int val4 ;
33134 int ecode4 = 0 ;
33135 PyObject * obj0 = 0 ;
33136 PyObject * obj1 = 0 ;
33137 PyObject * obj2 = 0 ;
33138 PyObject * obj3 = 0 ;
33139 char * kwnames[] = {
33140 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33141 };
33142
33143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33145 if (!SWIG_IsOK(res1)) {
33146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33147 }
33148 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33149 ecode2 = SWIG_AsVal_int(obj1, &val2);
33150 if (!SWIG_IsOK(ecode2)) {
33151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33152 }
33153 arg2 = static_cast< int >(val2);
33154 ecode3 = SWIG_AsVal_int(obj2, &val3);
33155 if (!SWIG_IsOK(ecode3)) {
33156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33157 }
33158 arg3 = static_cast< int >(val3);
33159 ecode4 = SWIG_AsVal_int(obj3, &val4);
33160 if (!SWIG_IsOK(ecode4)) {
33161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33162 }
33163 arg4 = static_cast< wxDragResult >(val4);
33164 {
33165 PyThreadState* __tstate = wxPyBeginAllowThreads();
33166 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33167 wxPyEndAllowThreads(__tstate);
33168 if (PyErr_Occurred()) SWIG_fail;
33169 }
33170 resultobj = SWIG_From_int(static_cast< int >(result));
33171 return resultobj;
33172 fail:
33173 return NULL;
33174 }
33175
33176
33177 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33178 PyObject *resultobj = 0;
33179 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33180 void *argp1 = 0 ;
33181 int res1 = 0 ;
33182 PyObject *swig_obj[1] ;
33183
33184 if (!args) SWIG_fail;
33185 swig_obj[0] = args;
33186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33187 if (!SWIG_IsOK(res1)) {
33188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33189 }
33190 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33191 {
33192 PyThreadState* __tstate = wxPyBeginAllowThreads();
33193 (arg1)->OnLeave();
33194 wxPyEndAllowThreads(__tstate);
33195 if (PyErr_Occurred()) SWIG_fail;
33196 }
33197 resultobj = SWIG_Py_Void();
33198 return resultobj;
33199 fail:
33200 return NULL;
33201 }
33202
33203
33204 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33205 PyObject *resultobj = 0;
33206 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33207 int arg2 ;
33208 int arg3 ;
33209 bool result;
33210 void *argp1 = 0 ;
33211 int res1 = 0 ;
33212 int val2 ;
33213 int ecode2 = 0 ;
33214 int val3 ;
33215 int ecode3 = 0 ;
33216 PyObject * obj0 = 0 ;
33217 PyObject * obj1 = 0 ;
33218 PyObject * obj2 = 0 ;
33219 char * kwnames[] = {
33220 (char *) "self",(char *) "x",(char *) "y", NULL
33221 };
33222
33223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33225 if (!SWIG_IsOK(res1)) {
33226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33227 }
33228 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33229 ecode2 = SWIG_AsVal_int(obj1, &val2);
33230 if (!SWIG_IsOK(ecode2)) {
33231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33232 }
33233 arg2 = static_cast< int >(val2);
33234 ecode3 = SWIG_AsVal_int(obj2, &val3);
33235 if (!SWIG_IsOK(ecode3)) {
33236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33237 }
33238 arg3 = static_cast< int >(val3);
33239 {
33240 PyThreadState* __tstate = wxPyBeginAllowThreads();
33241 result = (bool)(arg1)->OnDrop(arg2,arg3);
33242 wxPyEndAllowThreads(__tstate);
33243 if (PyErr_Occurred()) SWIG_fail;
33244 }
33245 {
33246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33247 }
33248 return resultobj;
33249 fail:
33250 return NULL;
33251 }
33252
33253
33254 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33255 PyObject *resultobj = 0;
33256 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33257 bool result;
33258 void *argp1 = 0 ;
33259 int res1 = 0 ;
33260 PyObject *swig_obj[1] ;
33261
33262 if (!args) SWIG_fail;
33263 swig_obj[0] = args;
33264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33265 if (!SWIG_IsOK(res1)) {
33266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33267 }
33268 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33269 {
33270 PyThreadState* __tstate = wxPyBeginAllowThreads();
33271 result = (bool)(arg1)->GetData();
33272 wxPyEndAllowThreads(__tstate);
33273 if (PyErr_Occurred()) SWIG_fail;
33274 }
33275 {
33276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33277 }
33278 return resultobj;
33279 fail:
33280 return NULL;
33281 }
33282
33283
33284 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33285 PyObject *resultobj = 0;
33286 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33287 wxDragResult arg2 ;
33288 void *argp1 = 0 ;
33289 int res1 = 0 ;
33290 int val2 ;
33291 int ecode2 = 0 ;
33292 PyObject * obj0 = 0 ;
33293 PyObject * obj1 = 0 ;
33294 char * kwnames[] = {
33295 (char *) "self",(char *) "action", NULL
33296 };
33297
33298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33300 if (!SWIG_IsOK(res1)) {
33301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33302 }
33303 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33304 ecode2 = SWIG_AsVal_int(obj1, &val2);
33305 if (!SWIG_IsOK(ecode2)) {
33306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33307 }
33308 arg2 = static_cast< wxDragResult >(val2);
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 (arg1)->SetDefaultAction(arg2);
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 resultobj = SWIG_Py_Void();
33316 return resultobj;
33317 fail:
33318 return NULL;
33319 }
33320
33321
33322 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33323 PyObject *resultobj = 0;
33324 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33325 wxDragResult result;
33326 void *argp1 = 0 ;
33327 int res1 = 0 ;
33328 PyObject *swig_obj[1] ;
33329
33330 if (!args) SWIG_fail;
33331 swig_obj[0] = args;
33332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33333 if (!SWIG_IsOK(res1)) {
33334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33335 }
33336 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33337 {
33338 PyThreadState* __tstate = wxPyBeginAllowThreads();
33339 result = (wxDragResult)(arg1)->GetDefaultAction();
33340 wxPyEndAllowThreads(__tstate);
33341 if (PyErr_Occurred()) SWIG_fail;
33342 }
33343 resultobj = SWIG_From_int(static_cast< int >(result));
33344 return resultobj;
33345 fail:
33346 return NULL;
33347 }
33348
33349
33350 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33351 PyObject *obj;
33352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33353 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33354 return SWIG_Py_Void();
33355 }
33356
33357 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33358 return SWIG_Python_InitShadowInstance(args);
33359 }
33360
33361 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33362 PyObject *resultobj = 0;
33363 wxPyTextDropTarget *result = 0 ;
33364
33365 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33369 wxPyEndAllowThreads(__tstate);
33370 if (PyErr_Occurred()) SWIG_fail;
33371 }
33372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33373 return resultobj;
33374 fail:
33375 return NULL;
33376 }
33377
33378
33379 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33380 PyObject *resultobj = 0;
33381 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33382 PyObject *arg2 = (PyObject *) 0 ;
33383 PyObject *arg3 = (PyObject *) 0 ;
33384 void *argp1 = 0 ;
33385 int res1 = 0 ;
33386 PyObject * obj0 = 0 ;
33387 PyObject * obj1 = 0 ;
33388 PyObject * obj2 = 0 ;
33389 char * kwnames[] = {
33390 (char *) "self",(char *) "self",(char *) "_class", NULL
33391 };
33392
33393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33395 if (!SWIG_IsOK(res1)) {
33396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33397 }
33398 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33399 arg2 = obj1;
33400 arg3 = obj2;
33401 {
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 (arg1)->_setCallbackInfo(arg2,arg3);
33404 wxPyEndAllowThreads(__tstate);
33405 if (PyErr_Occurred()) SWIG_fail;
33406 }
33407 resultobj = SWIG_Py_Void();
33408 return resultobj;
33409 fail:
33410 return NULL;
33411 }
33412
33413
33414 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33415 PyObject *resultobj = 0;
33416 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33417 int arg2 ;
33418 int arg3 ;
33419 wxString *arg4 = 0 ;
33420 bool result;
33421 void *argp1 = 0 ;
33422 int res1 = 0 ;
33423 int val2 ;
33424 int ecode2 = 0 ;
33425 int val3 ;
33426 int ecode3 = 0 ;
33427 bool temp4 = false ;
33428 PyObject * obj0 = 0 ;
33429 PyObject * obj1 = 0 ;
33430 PyObject * obj2 = 0 ;
33431 PyObject * obj3 = 0 ;
33432 char * kwnames[] = {
33433 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33434 };
33435
33436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33438 if (!SWIG_IsOK(res1)) {
33439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33440 }
33441 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33442 ecode2 = SWIG_AsVal_int(obj1, &val2);
33443 if (!SWIG_IsOK(ecode2)) {
33444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33445 }
33446 arg2 = static_cast< int >(val2);
33447 ecode3 = SWIG_AsVal_int(obj2, &val3);
33448 if (!SWIG_IsOK(ecode3)) {
33449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33450 }
33451 arg3 = static_cast< int >(val3);
33452 {
33453 arg4 = wxString_in_helper(obj3);
33454 if (arg4 == NULL) SWIG_fail;
33455 temp4 = true;
33456 }
33457 {
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33460 wxPyEndAllowThreads(__tstate);
33461 if (PyErr_Occurred()) SWIG_fail;
33462 }
33463 {
33464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33465 }
33466 {
33467 if (temp4)
33468 delete arg4;
33469 }
33470 return resultobj;
33471 fail:
33472 {
33473 if (temp4)
33474 delete arg4;
33475 }
33476 return NULL;
33477 }
33478
33479
33480 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33481 PyObject *resultobj = 0;
33482 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33483 int arg2 ;
33484 int arg3 ;
33485 wxDragResult arg4 ;
33486 wxDragResult result;
33487 void *argp1 = 0 ;
33488 int res1 = 0 ;
33489 int val2 ;
33490 int ecode2 = 0 ;
33491 int val3 ;
33492 int ecode3 = 0 ;
33493 int val4 ;
33494 int ecode4 = 0 ;
33495 PyObject * obj0 = 0 ;
33496 PyObject * obj1 = 0 ;
33497 PyObject * obj2 = 0 ;
33498 PyObject * obj3 = 0 ;
33499 char * kwnames[] = {
33500 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33501 };
33502
33503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33505 if (!SWIG_IsOK(res1)) {
33506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33507 }
33508 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33509 ecode2 = SWIG_AsVal_int(obj1, &val2);
33510 if (!SWIG_IsOK(ecode2)) {
33511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33512 }
33513 arg2 = static_cast< int >(val2);
33514 ecode3 = SWIG_AsVal_int(obj2, &val3);
33515 if (!SWIG_IsOK(ecode3)) {
33516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33517 }
33518 arg3 = static_cast< int >(val3);
33519 ecode4 = SWIG_AsVal_int(obj3, &val4);
33520 if (!SWIG_IsOK(ecode4)) {
33521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33522 }
33523 arg4 = static_cast< wxDragResult >(val4);
33524 {
33525 PyThreadState* __tstate = wxPyBeginAllowThreads();
33526 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33527 wxPyEndAllowThreads(__tstate);
33528 if (PyErr_Occurred()) SWIG_fail;
33529 }
33530 resultobj = SWIG_From_int(static_cast< int >(result));
33531 return resultobj;
33532 fail:
33533 return NULL;
33534 }
33535
33536
33537 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33538 PyObject *resultobj = 0;
33539 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33540 int arg2 ;
33541 int arg3 ;
33542 wxDragResult arg4 ;
33543 wxDragResult result;
33544 void *argp1 = 0 ;
33545 int res1 = 0 ;
33546 int val2 ;
33547 int ecode2 = 0 ;
33548 int val3 ;
33549 int ecode3 = 0 ;
33550 int val4 ;
33551 int ecode4 = 0 ;
33552 PyObject * obj0 = 0 ;
33553 PyObject * obj1 = 0 ;
33554 PyObject * obj2 = 0 ;
33555 PyObject * obj3 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33564 }
33565 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33566 ecode2 = SWIG_AsVal_int(obj1, &val2);
33567 if (!SWIG_IsOK(ecode2)) {
33568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33569 }
33570 arg2 = static_cast< int >(val2);
33571 ecode3 = SWIG_AsVal_int(obj2, &val3);
33572 if (!SWIG_IsOK(ecode3)) {
33573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33574 }
33575 arg3 = static_cast< int >(val3);
33576 ecode4 = SWIG_AsVal_int(obj3, &val4);
33577 if (!SWIG_IsOK(ecode4)) {
33578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33579 }
33580 arg4 = static_cast< wxDragResult >(val4);
33581 {
33582 PyThreadState* __tstate = wxPyBeginAllowThreads();
33583 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33584 wxPyEndAllowThreads(__tstate);
33585 if (PyErr_Occurred()) SWIG_fail;
33586 }
33587 resultobj = SWIG_From_int(static_cast< int >(result));
33588 return resultobj;
33589 fail:
33590 return NULL;
33591 }
33592
33593
33594 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33595 PyObject *resultobj = 0;
33596 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33597 void *argp1 = 0 ;
33598 int res1 = 0 ;
33599 PyObject *swig_obj[1] ;
33600
33601 if (!args) SWIG_fail;
33602 swig_obj[0] = args;
33603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33604 if (!SWIG_IsOK(res1)) {
33605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33606 }
33607 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33608 {
33609 PyThreadState* __tstate = wxPyBeginAllowThreads();
33610 (arg1)->OnLeave();
33611 wxPyEndAllowThreads(__tstate);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 }
33614 resultobj = SWIG_Py_Void();
33615 return resultobj;
33616 fail:
33617 return NULL;
33618 }
33619
33620
33621 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33622 PyObject *resultobj = 0;
33623 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33624 int arg2 ;
33625 int arg3 ;
33626 bool result;
33627 void *argp1 = 0 ;
33628 int res1 = 0 ;
33629 int val2 ;
33630 int ecode2 = 0 ;
33631 int val3 ;
33632 int ecode3 = 0 ;
33633 PyObject * obj0 = 0 ;
33634 PyObject * obj1 = 0 ;
33635 PyObject * obj2 = 0 ;
33636 char * kwnames[] = {
33637 (char *) "self",(char *) "x",(char *) "y", NULL
33638 };
33639
33640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33642 if (!SWIG_IsOK(res1)) {
33643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33644 }
33645 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33646 ecode2 = SWIG_AsVal_int(obj1, &val2);
33647 if (!SWIG_IsOK(ecode2)) {
33648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33649 }
33650 arg2 = static_cast< int >(val2);
33651 ecode3 = SWIG_AsVal_int(obj2, &val3);
33652 if (!SWIG_IsOK(ecode3)) {
33653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33654 }
33655 arg3 = static_cast< int >(val3);
33656 {
33657 PyThreadState* __tstate = wxPyBeginAllowThreads();
33658 result = (bool)(arg1)->OnDrop(arg2,arg3);
33659 wxPyEndAllowThreads(__tstate);
33660 if (PyErr_Occurred()) SWIG_fail;
33661 }
33662 {
33663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33664 }
33665 return resultobj;
33666 fail:
33667 return NULL;
33668 }
33669
33670
33671 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33672 PyObject *resultobj = 0;
33673 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33674 int arg2 ;
33675 int arg3 ;
33676 wxDragResult arg4 ;
33677 wxDragResult result;
33678 void *argp1 = 0 ;
33679 int res1 = 0 ;
33680 int val2 ;
33681 int ecode2 = 0 ;
33682 int val3 ;
33683 int ecode3 = 0 ;
33684 int val4 ;
33685 int ecode4 = 0 ;
33686 PyObject * obj0 = 0 ;
33687 PyObject * obj1 = 0 ;
33688 PyObject * obj2 = 0 ;
33689 PyObject * obj3 = 0 ;
33690 char * kwnames[] = {
33691 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33692 };
33693
33694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33696 if (!SWIG_IsOK(res1)) {
33697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33698 }
33699 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33700 ecode2 = SWIG_AsVal_int(obj1, &val2);
33701 if (!SWIG_IsOK(ecode2)) {
33702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33703 }
33704 arg2 = static_cast< int >(val2);
33705 ecode3 = SWIG_AsVal_int(obj2, &val3);
33706 if (!SWIG_IsOK(ecode3)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33708 }
33709 arg3 = static_cast< int >(val3);
33710 ecode4 = SWIG_AsVal_int(obj3, &val4);
33711 if (!SWIG_IsOK(ecode4)) {
33712 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33713 }
33714 arg4 = static_cast< wxDragResult >(val4);
33715 {
33716 PyThreadState* __tstate = wxPyBeginAllowThreads();
33717 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33718 wxPyEndAllowThreads(__tstate);
33719 if (PyErr_Occurred()) SWIG_fail;
33720 }
33721 resultobj = SWIG_From_int(static_cast< int >(result));
33722 return resultobj;
33723 fail:
33724 return NULL;
33725 }
33726
33727
33728 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33729 PyObject *obj;
33730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33731 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33732 return SWIG_Py_Void();
33733 }
33734
33735 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33736 return SWIG_Python_InitShadowInstance(args);
33737 }
33738
33739 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33740 PyObject *resultobj = 0;
33741 wxPyFileDropTarget *result = 0 ;
33742
33743 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33744 {
33745 PyThreadState* __tstate = wxPyBeginAllowThreads();
33746 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33747 wxPyEndAllowThreads(__tstate);
33748 if (PyErr_Occurred()) SWIG_fail;
33749 }
33750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33751 return resultobj;
33752 fail:
33753 return NULL;
33754 }
33755
33756
33757 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33758 PyObject *resultobj = 0;
33759 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33760 PyObject *arg2 = (PyObject *) 0 ;
33761 PyObject *arg3 = (PyObject *) 0 ;
33762 void *argp1 = 0 ;
33763 int res1 = 0 ;
33764 PyObject * obj0 = 0 ;
33765 PyObject * obj1 = 0 ;
33766 PyObject * obj2 = 0 ;
33767 char * kwnames[] = {
33768 (char *) "self",(char *) "self",(char *) "_class", NULL
33769 };
33770
33771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33773 if (!SWIG_IsOK(res1)) {
33774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33775 }
33776 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33777 arg2 = obj1;
33778 arg3 = obj2;
33779 {
33780 PyThreadState* __tstate = wxPyBeginAllowThreads();
33781 (arg1)->_setCallbackInfo(arg2,arg3);
33782 wxPyEndAllowThreads(__tstate);
33783 if (PyErr_Occurred()) SWIG_fail;
33784 }
33785 resultobj = SWIG_Py_Void();
33786 return resultobj;
33787 fail:
33788 return NULL;
33789 }
33790
33791
33792 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33793 PyObject *resultobj = 0;
33794 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33795 int arg2 ;
33796 int arg3 ;
33797 wxArrayString *arg4 = 0 ;
33798 bool result;
33799 void *argp1 = 0 ;
33800 int res1 = 0 ;
33801 int val2 ;
33802 int ecode2 = 0 ;
33803 int val3 ;
33804 int ecode3 = 0 ;
33805 bool temp4 = false ;
33806 PyObject * obj0 = 0 ;
33807 PyObject * obj1 = 0 ;
33808 PyObject * obj2 = 0 ;
33809 PyObject * obj3 = 0 ;
33810 char * kwnames[] = {
33811 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33812 };
33813
33814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33816 if (!SWIG_IsOK(res1)) {
33817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33818 }
33819 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33820 ecode2 = SWIG_AsVal_int(obj1, &val2);
33821 if (!SWIG_IsOK(ecode2)) {
33822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33823 }
33824 arg2 = static_cast< int >(val2);
33825 ecode3 = SWIG_AsVal_int(obj2, &val3);
33826 if (!SWIG_IsOK(ecode3)) {
33827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33828 }
33829 arg3 = static_cast< int >(val3);
33830 {
33831 if (! PySequence_Check(obj3)) {
33832 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33833 SWIG_fail;
33834 }
33835 arg4 = new wxArrayString;
33836 temp4 = true;
33837 int i, len=PySequence_Length(obj3);
33838 for (i=0; i<len; i++) {
33839 PyObject* item = PySequence_GetItem(obj3, i);
33840 wxString* s = wxString_in_helper(item);
33841 if (PyErr_Occurred()) SWIG_fail;
33842 arg4->Add(*s);
33843 delete s;
33844 Py_DECREF(item);
33845 }
33846 }
33847 {
33848 PyThreadState* __tstate = wxPyBeginAllowThreads();
33849 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33850 wxPyEndAllowThreads(__tstate);
33851 if (PyErr_Occurred()) SWIG_fail;
33852 }
33853 {
33854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33855 }
33856 {
33857 if (temp4) delete arg4;
33858 }
33859 return resultobj;
33860 fail:
33861 {
33862 if (temp4) delete arg4;
33863 }
33864 return NULL;
33865 }
33866
33867
33868 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33869 PyObject *resultobj = 0;
33870 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33871 int arg2 ;
33872 int arg3 ;
33873 wxDragResult arg4 ;
33874 wxDragResult result;
33875 void *argp1 = 0 ;
33876 int res1 = 0 ;
33877 int val2 ;
33878 int ecode2 = 0 ;
33879 int val3 ;
33880 int ecode3 = 0 ;
33881 int val4 ;
33882 int ecode4 = 0 ;
33883 PyObject * obj0 = 0 ;
33884 PyObject * obj1 = 0 ;
33885 PyObject * obj2 = 0 ;
33886 PyObject * obj3 = 0 ;
33887 char * kwnames[] = {
33888 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33889 };
33890
33891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33893 if (!SWIG_IsOK(res1)) {
33894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33895 }
33896 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33897 ecode2 = SWIG_AsVal_int(obj1, &val2);
33898 if (!SWIG_IsOK(ecode2)) {
33899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33900 }
33901 arg2 = static_cast< int >(val2);
33902 ecode3 = SWIG_AsVal_int(obj2, &val3);
33903 if (!SWIG_IsOK(ecode3)) {
33904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33905 }
33906 arg3 = static_cast< int >(val3);
33907 ecode4 = SWIG_AsVal_int(obj3, &val4);
33908 if (!SWIG_IsOK(ecode4)) {
33909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33910 }
33911 arg4 = static_cast< wxDragResult >(val4);
33912 {
33913 PyThreadState* __tstate = wxPyBeginAllowThreads();
33914 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33915 wxPyEndAllowThreads(__tstate);
33916 if (PyErr_Occurred()) SWIG_fail;
33917 }
33918 resultobj = SWIG_From_int(static_cast< int >(result));
33919 return resultobj;
33920 fail:
33921 return NULL;
33922 }
33923
33924
33925 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33926 PyObject *resultobj = 0;
33927 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33928 int arg2 ;
33929 int arg3 ;
33930 wxDragResult arg4 ;
33931 wxDragResult result;
33932 void *argp1 = 0 ;
33933 int res1 = 0 ;
33934 int val2 ;
33935 int ecode2 = 0 ;
33936 int val3 ;
33937 int ecode3 = 0 ;
33938 int val4 ;
33939 int ecode4 = 0 ;
33940 PyObject * obj0 = 0 ;
33941 PyObject * obj1 = 0 ;
33942 PyObject * obj2 = 0 ;
33943 PyObject * obj3 = 0 ;
33944 char * kwnames[] = {
33945 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33946 };
33947
33948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33950 if (!SWIG_IsOK(res1)) {
33951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33952 }
33953 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33954 ecode2 = SWIG_AsVal_int(obj1, &val2);
33955 if (!SWIG_IsOK(ecode2)) {
33956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33957 }
33958 arg2 = static_cast< int >(val2);
33959 ecode3 = SWIG_AsVal_int(obj2, &val3);
33960 if (!SWIG_IsOK(ecode3)) {
33961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33962 }
33963 arg3 = static_cast< int >(val3);
33964 ecode4 = SWIG_AsVal_int(obj3, &val4);
33965 if (!SWIG_IsOK(ecode4)) {
33966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33967 }
33968 arg4 = static_cast< wxDragResult >(val4);
33969 {
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 resultobj = SWIG_From_int(static_cast< int >(result));
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33983 PyObject *resultobj = 0;
33984 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 PyObject *swig_obj[1] ;
33988
33989 if (!args) SWIG_fail;
33990 swig_obj[0] = args;
33991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33992 if (!SWIG_IsOK(res1)) {
33993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33994 }
33995 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 (arg1)->OnLeave();
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 resultobj = SWIG_Py_Void();
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = 0;
34011 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34012 int arg2 ;
34013 int arg3 ;
34014 bool result;
34015 void *argp1 = 0 ;
34016 int res1 = 0 ;
34017 int val2 ;
34018 int ecode2 = 0 ;
34019 int val3 ;
34020 int ecode3 = 0 ;
34021 PyObject * obj0 = 0 ;
34022 PyObject * obj1 = 0 ;
34023 PyObject * obj2 = 0 ;
34024 char * kwnames[] = {
34025 (char *) "self",(char *) "x",(char *) "y", NULL
34026 };
34027
34028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34032 }
34033 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34034 ecode2 = SWIG_AsVal_int(obj1, &val2);
34035 if (!SWIG_IsOK(ecode2)) {
34036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34037 }
34038 arg2 = static_cast< int >(val2);
34039 ecode3 = SWIG_AsVal_int(obj2, &val3);
34040 if (!SWIG_IsOK(ecode3)) {
34041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34042 }
34043 arg3 = static_cast< int >(val3);
34044 {
34045 PyThreadState* __tstate = wxPyBeginAllowThreads();
34046 result = (bool)(arg1)->OnDrop(arg2,arg3);
34047 wxPyEndAllowThreads(__tstate);
34048 if (PyErr_Occurred()) SWIG_fail;
34049 }
34050 {
34051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34052 }
34053 return resultobj;
34054 fail:
34055 return NULL;
34056 }
34057
34058
34059 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34060 PyObject *resultobj = 0;
34061 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34062 int arg2 ;
34063 int arg3 ;
34064 wxDragResult arg4 ;
34065 wxDragResult result;
34066 void *argp1 = 0 ;
34067 int res1 = 0 ;
34068 int val2 ;
34069 int ecode2 = 0 ;
34070 int val3 ;
34071 int ecode3 = 0 ;
34072 int val4 ;
34073 int ecode4 = 0 ;
34074 PyObject * obj0 = 0 ;
34075 PyObject * obj1 = 0 ;
34076 PyObject * obj2 = 0 ;
34077 PyObject * obj3 = 0 ;
34078 char * kwnames[] = {
34079 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34080 };
34081
34082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34084 if (!SWIG_IsOK(res1)) {
34085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34086 }
34087 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34088 ecode2 = SWIG_AsVal_int(obj1, &val2);
34089 if (!SWIG_IsOK(ecode2)) {
34090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34091 }
34092 arg2 = static_cast< int >(val2);
34093 ecode3 = SWIG_AsVal_int(obj2, &val3);
34094 if (!SWIG_IsOK(ecode3)) {
34095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34096 }
34097 arg3 = static_cast< int >(val3);
34098 ecode4 = SWIG_AsVal_int(obj3, &val4);
34099 if (!SWIG_IsOK(ecode4)) {
34100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34101 }
34102 arg4 = static_cast< wxDragResult >(val4);
34103 {
34104 PyThreadState* __tstate = wxPyBeginAllowThreads();
34105 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34106 wxPyEndAllowThreads(__tstate);
34107 if (PyErr_Occurred()) SWIG_fail;
34108 }
34109 resultobj = SWIG_From_int(static_cast< int >(result));
34110 return resultobj;
34111 fail:
34112 return NULL;
34113 }
34114
34115
34116 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34117 PyObject *obj;
34118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34119 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
34120 return SWIG_Py_Void();
34121 }
34122
34123 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34124 return SWIG_Python_InitShadowInstance(args);
34125 }
34126
34127 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34128 PyObject *resultobj = 0;
34129 wxClipboard *result = 0 ;
34130
34131 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34132 {
34133 PyThreadState* __tstate = wxPyBeginAllowThreads();
34134 result = (wxClipboard *)new wxClipboard();
34135 wxPyEndAllowThreads(__tstate);
34136 if (PyErr_Occurred()) SWIG_fail;
34137 }
34138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34139 return resultobj;
34140 fail:
34141 return NULL;
34142 }
34143
34144
34145 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34146 PyObject *resultobj = 0;
34147 wxClipboard *arg1 = (wxClipboard *) 0 ;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 PyObject *swig_obj[1] ;
34151
34152 if (!args) SWIG_fail;
34153 swig_obj[0] = args;
34154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34155 if (!SWIG_IsOK(res1)) {
34156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34157 }
34158 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34159 {
34160 PyThreadState* __tstate = wxPyBeginAllowThreads();
34161 delete arg1;
34162
34163 wxPyEndAllowThreads(__tstate);
34164 if (PyErr_Occurred()) SWIG_fail;
34165 }
34166 resultobj = SWIG_Py_Void();
34167 return resultobj;
34168 fail:
34169 return NULL;
34170 }
34171
34172
34173 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34174 PyObject *resultobj = 0;
34175 wxClipboard *arg1 = (wxClipboard *) 0 ;
34176 bool result;
34177 void *argp1 = 0 ;
34178 int res1 = 0 ;
34179 PyObject *swig_obj[1] ;
34180
34181 if (!args) SWIG_fail;
34182 swig_obj[0] = args;
34183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34184 if (!SWIG_IsOK(res1)) {
34185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34186 }
34187 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 result = (bool)(arg1)->Open();
34191 wxPyEndAllowThreads(__tstate);
34192 if (PyErr_Occurred()) SWIG_fail;
34193 }
34194 {
34195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34196 }
34197 return resultobj;
34198 fail:
34199 return NULL;
34200 }
34201
34202
34203 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34204 PyObject *resultobj = 0;
34205 wxClipboard *arg1 = (wxClipboard *) 0 ;
34206 void *argp1 = 0 ;
34207 int res1 = 0 ;
34208 PyObject *swig_obj[1] ;
34209
34210 if (!args) SWIG_fail;
34211 swig_obj[0] = args;
34212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34213 if (!SWIG_IsOK(res1)) {
34214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34215 }
34216 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34217 {
34218 PyThreadState* __tstate = wxPyBeginAllowThreads();
34219 (arg1)->Close();
34220 wxPyEndAllowThreads(__tstate);
34221 if (PyErr_Occurred()) SWIG_fail;
34222 }
34223 resultobj = SWIG_Py_Void();
34224 return resultobj;
34225 fail:
34226 return NULL;
34227 }
34228
34229
34230 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34231 PyObject *resultobj = 0;
34232 wxClipboard *arg1 = (wxClipboard *) 0 ;
34233 bool result;
34234 void *argp1 = 0 ;
34235 int res1 = 0 ;
34236 PyObject *swig_obj[1] ;
34237
34238 if (!args) SWIG_fail;
34239 swig_obj[0] = args;
34240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34241 if (!SWIG_IsOK(res1)) {
34242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34243 }
34244 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34245 {
34246 PyThreadState* __tstate = wxPyBeginAllowThreads();
34247 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34248 wxPyEndAllowThreads(__tstate);
34249 if (PyErr_Occurred()) SWIG_fail;
34250 }
34251 {
34252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34253 }
34254 return resultobj;
34255 fail:
34256 return NULL;
34257 }
34258
34259
34260 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34261 PyObject *resultobj = 0;
34262 wxClipboard *arg1 = (wxClipboard *) 0 ;
34263 wxDataObject *arg2 = (wxDataObject *) 0 ;
34264 bool result;
34265 void *argp1 = 0 ;
34266 int res1 = 0 ;
34267 int res2 = 0 ;
34268 PyObject * obj0 = 0 ;
34269 PyObject * obj1 = 0 ;
34270 char * kwnames[] = {
34271 (char *) "self",(char *) "data", NULL
34272 };
34273
34274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34276 if (!SWIG_IsOK(res1)) {
34277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34278 }
34279 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34280 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34281 if (!SWIG_IsOK(res2)) {
34282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34283 }
34284 {
34285 PyThreadState* __tstate = wxPyBeginAllowThreads();
34286 result = (bool)(arg1)->AddData(arg2);
34287 wxPyEndAllowThreads(__tstate);
34288 if (PyErr_Occurred()) SWIG_fail;
34289 }
34290 {
34291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34292 }
34293 return resultobj;
34294 fail:
34295 return NULL;
34296 }
34297
34298
34299 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34300 PyObject *resultobj = 0;
34301 wxClipboard *arg1 = (wxClipboard *) 0 ;
34302 wxDataObject *arg2 = (wxDataObject *) 0 ;
34303 bool result;
34304 void *argp1 = 0 ;
34305 int res1 = 0 ;
34306 int res2 = 0 ;
34307 PyObject * obj0 = 0 ;
34308 PyObject * obj1 = 0 ;
34309 char * kwnames[] = {
34310 (char *) "self",(char *) "data", NULL
34311 };
34312
34313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34315 if (!SWIG_IsOK(res1)) {
34316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34317 }
34318 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34319 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34320 if (!SWIG_IsOK(res2)) {
34321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34322 }
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 result = (bool)(arg1)->SetData(arg2);
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 {
34330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34331 }
34332 return resultobj;
34333 fail:
34334 return NULL;
34335 }
34336
34337
34338 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34339 PyObject *resultobj = 0;
34340 wxClipboard *arg1 = (wxClipboard *) 0 ;
34341 wxDataFormat *arg2 = 0 ;
34342 bool result;
34343 void *argp1 = 0 ;
34344 int res1 = 0 ;
34345 void *argp2 = 0 ;
34346 int res2 = 0 ;
34347 PyObject * obj0 = 0 ;
34348 PyObject * obj1 = 0 ;
34349 char * kwnames[] = {
34350 (char *) "self",(char *) "format", NULL
34351 };
34352
34353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34355 if (!SWIG_IsOK(res1)) {
34356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34357 }
34358 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34359 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34360 if (!SWIG_IsOK(res2)) {
34361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34362 }
34363 if (!argp2) {
34364 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34365 }
34366 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34367 {
34368 PyThreadState* __tstate = wxPyBeginAllowThreads();
34369 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34370 wxPyEndAllowThreads(__tstate);
34371 if (PyErr_Occurred()) SWIG_fail;
34372 }
34373 {
34374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34375 }
34376 return resultobj;
34377 fail:
34378 return NULL;
34379 }
34380
34381
34382 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34383 PyObject *resultobj = 0;
34384 wxClipboard *arg1 = (wxClipboard *) 0 ;
34385 wxDataObject *arg2 = 0 ;
34386 bool result;
34387 void *argp1 = 0 ;
34388 int res1 = 0 ;
34389 void *argp2 = 0 ;
34390 int res2 = 0 ;
34391 PyObject * obj0 = 0 ;
34392 PyObject * obj1 = 0 ;
34393 char * kwnames[] = {
34394 (char *) "self",(char *) "data", NULL
34395 };
34396
34397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34399 if (!SWIG_IsOK(res1)) {
34400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34401 }
34402 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34403 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34404 if (!SWIG_IsOK(res2)) {
34405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34406 }
34407 if (!argp2) {
34408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34409 }
34410 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34411 {
34412 PyThreadState* __tstate = wxPyBeginAllowThreads();
34413 result = (bool)(arg1)->GetData(*arg2);
34414 wxPyEndAllowThreads(__tstate);
34415 if (PyErr_Occurred()) SWIG_fail;
34416 }
34417 {
34418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34419 }
34420 return resultobj;
34421 fail:
34422 return NULL;
34423 }
34424
34425
34426 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34427 PyObject *resultobj = 0;
34428 wxClipboard *arg1 = (wxClipboard *) 0 ;
34429 void *argp1 = 0 ;
34430 int res1 = 0 ;
34431 PyObject *swig_obj[1] ;
34432
34433 if (!args) SWIG_fail;
34434 swig_obj[0] = args;
34435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34436 if (!SWIG_IsOK(res1)) {
34437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34438 }
34439 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34440 {
34441 PyThreadState* __tstate = wxPyBeginAllowThreads();
34442 (arg1)->Clear();
34443 wxPyEndAllowThreads(__tstate);
34444 if (PyErr_Occurred()) SWIG_fail;
34445 }
34446 resultobj = SWIG_Py_Void();
34447 return resultobj;
34448 fail:
34449 return NULL;
34450 }
34451
34452
34453 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34454 PyObject *resultobj = 0;
34455 wxClipboard *arg1 = (wxClipboard *) 0 ;
34456 bool result;
34457 void *argp1 = 0 ;
34458 int res1 = 0 ;
34459 PyObject *swig_obj[1] ;
34460
34461 if (!args) SWIG_fail;
34462 swig_obj[0] = args;
34463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34464 if (!SWIG_IsOK(res1)) {
34465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34466 }
34467 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34468 {
34469 PyThreadState* __tstate = wxPyBeginAllowThreads();
34470 result = (bool)(arg1)->Flush();
34471 wxPyEndAllowThreads(__tstate);
34472 if (PyErr_Occurred()) SWIG_fail;
34473 }
34474 {
34475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34476 }
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34484 PyObject *resultobj = 0;
34485 wxClipboard *arg1 = (wxClipboard *) 0 ;
34486 bool arg2 = (bool) true ;
34487 void *argp1 = 0 ;
34488 int res1 = 0 ;
34489 bool val2 ;
34490 int ecode2 = 0 ;
34491 PyObject * obj0 = 0 ;
34492 PyObject * obj1 = 0 ;
34493 char * kwnames[] = {
34494 (char *) "self",(char *) "primary", NULL
34495 };
34496
34497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34499 if (!SWIG_IsOK(res1)) {
34500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34501 }
34502 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34503 if (obj1) {
34504 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34505 if (!SWIG_IsOK(ecode2)) {
34506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34507 }
34508 arg2 = static_cast< bool >(val2);
34509 }
34510 {
34511 PyThreadState* __tstate = wxPyBeginAllowThreads();
34512 (arg1)->UsePrimarySelection(arg2);
34513 wxPyEndAllowThreads(__tstate);
34514 if (PyErr_Occurred()) SWIG_fail;
34515 }
34516 resultobj = SWIG_Py_Void();
34517 return resultobj;
34518 fail:
34519 return NULL;
34520 }
34521
34522
34523 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34524 PyObject *resultobj = 0;
34525 wxClipboard *result = 0 ;
34526
34527 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 result = (wxClipboard *)wxClipboard::Get();
34531 wxPyEndAllowThreads(__tstate);
34532 if (PyErr_Occurred()) SWIG_fail;
34533 }
34534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34535 return resultobj;
34536 fail:
34537 return NULL;
34538 }
34539
34540
34541 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34542 PyObject *obj;
34543 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34544 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34545 return SWIG_Py_Void();
34546 }
34547
34548 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34549 return SWIG_Python_InitShadowInstance(args);
34550 }
34551
34552 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34553 PyObject *resultobj = 0;
34554 wxClipboard *arg1 = (wxClipboard *) NULL ;
34555 wxClipboardLocker *result = 0 ;
34556 void *argp1 = 0 ;
34557 int res1 = 0 ;
34558 PyObject * obj0 = 0 ;
34559 char * kwnames[] = {
34560 (char *) "clipboard", NULL
34561 };
34562
34563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34564 if (obj0) {
34565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34566 if (!SWIG_IsOK(res1)) {
34567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34568 }
34569 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34570 }
34571 {
34572 PyThreadState* __tstate = wxPyBeginAllowThreads();
34573 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34574 wxPyEndAllowThreads(__tstate);
34575 if (PyErr_Occurred()) SWIG_fail;
34576 }
34577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34578 return resultobj;
34579 fail:
34580 return NULL;
34581 }
34582
34583
34584 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34585 PyObject *resultobj = 0;
34586 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34587 void *argp1 = 0 ;
34588 int res1 = 0 ;
34589 PyObject *swig_obj[1] ;
34590
34591 if (!args) SWIG_fail;
34592 swig_obj[0] = args;
34593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34594 if (!SWIG_IsOK(res1)) {
34595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34596 }
34597 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34598 {
34599 PyThreadState* __tstate = wxPyBeginAllowThreads();
34600 delete arg1;
34601
34602 wxPyEndAllowThreads(__tstate);
34603 if (PyErr_Occurred()) SWIG_fail;
34604 }
34605 resultobj = SWIG_Py_Void();
34606 return resultobj;
34607 fail:
34608 return NULL;
34609 }
34610
34611
34612 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34613 PyObject *resultobj = 0;
34614 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34615 bool result;
34616 void *argp1 = 0 ;
34617 int res1 = 0 ;
34618 PyObject *swig_obj[1] ;
34619
34620 if (!args) SWIG_fail;
34621 swig_obj[0] = args;
34622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34623 if (!SWIG_IsOK(res1)) {
34624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34625 }
34626 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34627 {
34628 PyThreadState* __tstate = wxPyBeginAllowThreads();
34629 result = (bool)wxClipboardLocker___nonzero__(arg1);
34630 wxPyEndAllowThreads(__tstate);
34631 if (PyErr_Occurred()) SWIG_fail;
34632 }
34633 {
34634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34635 }
34636 return resultobj;
34637 fail:
34638 return NULL;
34639 }
34640
34641
34642 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34643 PyObject *obj;
34644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34645 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34646 return SWIG_Py_Void();
34647 }
34648
34649 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34650 return SWIG_Python_InitShadowInstance(args);
34651 }
34652
34653 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34654 PyObject *resultobj = 0;
34655 int arg1 = (int) 0 ;
34656 int arg2 = (int) 0 ;
34657 int arg3 = (int) 0 ;
34658 int arg4 = (int) 0 ;
34659 wxVideoMode *result = 0 ;
34660 int val1 ;
34661 int ecode1 = 0 ;
34662 int val2 ;
34663 int ecode2 = 0 ;
34664 int val3 ;
34665 int ecode3 = 0 ;
34666 int val4 ;
34667 int ecode4 = 0 ;
34668 PyObject * obj0 = 0 ;
34669 PyObject * obj1 = 0 ;
34670 PyObject * obj2 = 0 ;
34671 PyObject * obj3 = 0 ;
34672 char * kwnames[] = {
34673 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34674 };
34675
34676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34677 if (obj0) {
34678 ecode1 = SWIG_AsVal_int(obj0, &val1);
34679 if (!SWIG_IsOK(ecode1)) {
34680 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34681 }
34682 arg1 = static_cast< int >(val1);
34683 }
34684 if (obj1) {
34685 ecode2 = SWIG_AsVal_int(obj1, &val2);
34686 if (!SWIG_IsOK(ecode2)) {
34687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34688 }
34689 arg2 = static_cast< int >(val2);
34690 }
34691 if (obj2) {
34692 ecode3 = SWIG_AsVal_int(obj2, &val3);
34693 if (!SWIG_IsOK(ecode3)) {
34694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34695 }
34696 arg3 = static_cast< int >(val3);
34697 }
34698 if (obj3) {
34699 ecode4 = SWIG_AsVal_int(obj3, &val4);
34700 if (!SWIG_IsOK(ecode4)) {
34701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34702 }
34703 arg4 = static_cast< int >(val4);
34704 }
34705 {
34706 PyThreadState* __tstate = wxPyBeginAllowThreads();
34707 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34708 wxPyEndAllowThreads(__tstate);
34709 if (PyErr_Occurred()) SWIG_fail;
34710 }
34711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34712 return resultobj;
34713 fail:
34714 return NULL;
34715 }
34716
34717
34718 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34719 PyObject *resultobj = 0;
34720 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34721 void *argp1 = 0 ;
34722 int res1 = 0 ;
34723 PyObject *swig_obj[1] ;
34724
34725 if (!args) SWIG_fail;
34726 swig_obj[0] = args;
34727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34728 if (!SWIG_IsOK(res1)) {
34729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34730 }
34731 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34732 {
34733 PyThreadState* __tstate = wxPyBeginAllowThreads();
34734 delete arg1;
34735
34736 wxPyEndAllowThreads(__tstate);
34737 if (PyErr_Occurred()) SWIG_fail;
34738 }
34739 resultobj = SWIG_Py_Void();
34740 return resultobj;
34741 fail:
34742 return NULL;
34743 }
34744
34745
34746 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34747 PyObject *resultobj = 0;
34748 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34749 wxVideoMode *arg2 = 0 ;
34750 bool result;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 void *argp2 = 0 ;
34754 int res2 = 0 ;
34755 PyObject * obj0 = 0 ;
34756 PyObject * obj1 = 0 ;
34757 char * kwnames[] = {
34758 (char *) "self",(char *) "other", NULL
34759 };
34760
34761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34763 if (!SWIG_IsOK(res1)) {
34764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34765 }
34766 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34767 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34768 if (!SWIG_IsOK(res2)) {
34769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34770 }
34771 if (!argp2) {
34772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34773 }
34774 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34778 wxPyEndAllowThreads(__tstate);
34779 if (PyErr_Occurred()) SWIG_fail;
34780 }
34781 {
34782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34783 }
34784 return resultobj;
34785 fail:
34786 return NULL;
34787 }
34788
34789
34790 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34791 PyObject *resultobj = 0;
34792 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34793 int result;
34794 void *argp1 = 0 ;
34795 int res1 = 0 ;
34796 PyObject *swig_obj[1] ;
34797
34798 if (!args) SWIG_fail;
34799 swig_obj[0] = args;
34800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34803 }
34804 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34805 {
34806 PyThreadState* __tstate = wxPyBeginAllowThreads();
34807 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34808 wxPyEndAllowThreads(__tstate);
34809 if (PyErr_Occurred()) SWIG_fail;
34810 }
34811 resultobj = SWIG_From_int(static_cast< int >(result));
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34819 PyObject *resultobj = 0;
34820 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34821 int result;
34822 void *argp1 = 0 ;
34823 int res1 = 0 ;
34824 PyObject *swig_obj[1] ;
34825
34826 if (!args) SWIG_fail;
34827 swig_obj[0] = args;
34828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34829 if (!SWIG_IsOK(res1)) {
34830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34831 }
34832 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34833 {
34834 PyThreadState* __tstate = wxPyBeginAllowThreads();
34835 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34836 wxPyEndAllowThreads(__tstate);
34837 if (PyErr_Occurred()) SWIG_fail;
34838 }
34839 resultobj = SWIG_From_int(static_cast< int >(result));
34840 return resultobj;
34841 fail:
34842 return NULL;
34843 }
34844
34845
34846 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34847 PyObject *resultobj = 0;
34848 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34849 int result;
34850 void *argp1 = 0 ;
34851 int res1 = 0 ;
34852 PyObject *swig_obj[1] ;
34853
34854 if (!args) SWIG_fail;
34855 swig_obj[0] = args;
34856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34857 if (!SWIG_IsOK(res1)) {
34858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34859 }
34860 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34861 {
34862 PyThreadState* __tstate = wxPyBeginAllowThreads();
34863 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34864 wxPyEndAllowThreads(__tstate);
34865 if (PyErr_Occurred()) SWIG_fail;
34866 }
34867 resultobj = SWIG_From_int(static_cast< int >(result));
34868 return resultobj;
34869 fail:
34870 return NULL;
34871 }
34872
34873
34874 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34875 PyObject *resultobj = 0;
34876 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34877 bool result;
34878 void *argp1 = 0 ;
34879 int res1 = 0 ;
34880 PyObject *swig_obj[1] ;
34881
34882 if (!args) SWIG_fail;
34883 swig_obj[0] = args;
34884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34885 if (!SWIG_IsOK(res1)) {
34886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34887 }
34888 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34889 {
34890 PyThreadState* __tstate = wxPyBeginAllowThreads();
34891 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34892 wxPyEndAllowThreads(__tstate);
34893 if (PyErr_Occurred()) SWIG_fail;
34894 }
34895 {
34896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34897 }
34898 return resultobj;
34899 fail:
34900 return NULL;
34901 }
34902
34903
34904 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34905 PyObject *resultobj = 0;
34906 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34907 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34908 bool result;
34909 void *argp1 = 0 ;
34910 int res1 = 0 ;
34911 void *argp2 = 0 ;
34912 int res2 = 0 ;
34913 PyObject * obj0 = 0 ;
34914 PyObject * obj1 = 0 ;
34915 char * kwnames[] = {
34916 (char *) "self",(char *) "other", NULL
34917 };
34918
34919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34921 if (!SWIG_IsOK(res1)) {
34922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34923 }
34924 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34926 if (!SWIG_IsOK(res2)) {
34927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34928 }
34929 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34930 {
34931 PyThreadState* __tstate = wxPyBeginAllowThreads();
34932 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34933 wxPyEndAllowThreads(__tstate);
34934 if (PyErr_Occurred()) SWIG_fail;
34935 }
34936 {
34937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34938 }
34939 return resultobj;
34940 fail:
34941 return NULL;
34942 }
34943
34944
34945 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34946 PyObject *resultobj = 0;
34947 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34948 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34949 bool result;
34950 void *argp1 = 0 ;
34951 int res1 = 0 ;
34952 void *argp2 = 0 ;
34953 int res2 = 0 ;
34954 PyObject * obj0 = 0 ;
34955 PyObject * obj1 = 0 ;
34956 char * kwnames[] = {
34957 (char *) "self",(char *) "other", NULL
34958 };
34959
34960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34962 if (!SWIG_IsOK(res1)) {
34963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34964 }
34965 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34967 if (!SWIG_IsOK(res2)) {
34968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34969 }
34970 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34974 wxPyEndAllowThreads(__tstate);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 }
34977 {
34978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34979 }
34980 return resultobj;
34981 fail:
34982 return NULL;
34983 }
34984
34985
34986 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34987 PyObject *resultobj = 0;
34988 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34989 int arg2 ;
34990 void *argp1 = 0 ;
34991 int res1 = 0 ;
34992 int val2 ;
34993 int ecode2 = 0 ;
34994 PyObject *swig_obj[2] ;
34995
34996 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34998 if (!SWIG_IsOK(res1)) {
34999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35000 }
35001 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35002 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35003 if (!SWIG_IsOK(ecode2)) {
35004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35005 }
35006 arg2 = static_cast< int >(val2);
35007 if (arg1) (arg1)->w = arg2;
35008
35009 resultobj = SWIG_Py_Void();
35010 return resultobj;
35011 fail:
35012 return NULL;
35013 }
35014
35015
35016 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35017 PyObject *resultobj = 0;
35018 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35019 int result;
35020 void *argp1 = 0 ;
35021 int res1 = 0 ;
35022 PyObject *swig_obj[1] ;
35023
35024 if (!args) SWIG_fail;
35025 swig_obj[0] = args;
35026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35027 if (!SWIG_IsOK(res1)) {
35028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35029 }
35030 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35031 result = (int) ((arg1)->w);
35032 resultobj = SWIG_From_int(static_cast< int >(result));
35033 return resultobj;
35034 fail:
35035 return NULL;
35036 }
35037
35038
35039 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35040 PyObject *resultobj = 0;
35041 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35042 int arg2 ;
35043 void *argp1 = 0 ;
35044 int res1 = 0 ;
35045 int val2 ;
35046 int ecode2 = 0 ;
35047 PyObject *swig_obj[2] ;
35048
35049 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
35050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35051 if (!SWIG_IsOK(res1)) {
35052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35053 }
35054 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35055 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35056 if (!SWIG_IsOK(ecode2)) {
35057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
35058 }
35059 arg2 = static_cast< int >(val2);
35060 if (arg1) (arg1)->h = arg2;
35061
35062 resultobj = SWIG_Py_Void();
35063 return resultobj;
35064 fail:
35065 return NULL;
35066 }
35067
35068
35069 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35070 PyObject *resultobj = 0;
35071 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35072 int result;
35073 void *argp1 = 0 ;
35074 int res1 = 0 ;
35075 PyObject *swig_obj[1] ;
35076
35077 if (!args) SWIG_fail;
35078 swig_obj[0] = args;
35079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35080 if (!SWIG_IsOK(res1)) {
35081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35082 }
35083 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35084 result = (int) ((arg1)->h);
35085 resultobj = SWIG_From_int(static_cast< int >(result));
35086 return resultobj;
35087 fail:
35088 return NULL;
35089 }
35090
35091
35092 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35093 PyObject *resultobj = 0;
35094 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35095 int arg2 ;
35096 void *argp1 = 0 ;
35097 int res1 = 0 ;
35098 int val2 ;
35099 int ecode2 = 0 ;
35100 PyObject *swig_obj[2] ;
35101
35102 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
35103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35104 if (!SWIG_IsOK(res1)) {
35105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35106 }
35107 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35109 if (!SWIG_IsOK(ecode2)) {
35110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
35111 }
35112 arg2 = static_cast< int >(val2);
35113 if (arg1) (arg1)->bpp = arg2;
35114
35115 resultobj = SWIG_Py_Void();
35116 return resultobj;
35117 fail:
35118 return NULL;
35119 }
35120
35121
35122 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35123 PyObject *resultobj = 0;
35124 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35125 int result;
35126 void *argp1 = 0 ;
35127 int res1 = 0 ;
35128 PyObject *swig_obj[1] ;
35129
35130 if (!args) SWIG_fail;
35131 swig_obj[0] = args;
35132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35133 if (!SWIG_IsOK(res1)) {
35134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35135 }
35136 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35137 result = (int) ((arg1)->bpp);
35138 resultobj = SWIG_From_int(static_cast< int >(result));
35139 return resultobj;
35140 fail:
35141 return NULL;
35142 }
35143
35144
35145 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35146 PyObject *resultobj = 0;
35147 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35148 int arg2 ;
35149 void *argp1 = 0 ;
35150 int res1 = 0 ;
35151 int val2 ;
35152 int ecode2 = 0 ;
35153 PyObject *swig_obj[2] ;
35154
35155 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35157 if (!SWIG_IsOK(res1)) {
35158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35159 }
35160 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35161 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35162 if (!SWIG_IsOK(ecode2)) {
35163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35164 }
35165 arg2 = static_cast< int >(val2);
35166 if (arg1) (arg1)->refresh = arg2;
35167
35168 resultobj = SWIG_Py_Void();
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35178 int result;
35179 void *argp1 = 0 ;
35180 int res1 = 0 ;
35181 PyObject *swig_obj[1] ;
35182
35183 if (!args) SWIG_fail;
35184 swig_obj[0] = args;
35185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35186 if (!SWIG_IsOK(res1)) {
35187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35188 }
35189 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35190 result = (int) ((arg1)->refresh);
35191 resultobj = SWIG_From_int(static_cast< int >(result));
35192 return resultobj;
35193 fail:
35194 return NULL;
35195 }
35196
35197
35198 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35199 PyObject *obj;
35200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35201 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35202 return SWIG_Py_Void();
35203 }
35204
35205 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35206 return SWIG_Python_InitShadowInstance(args);
35207 }
35208
35209 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35210 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35211 return 1;
35212 }
35213
35214
35215 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35216 PyObject *pyobj = 0;
35217
35218 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35219 return pyobj;
35220 }
35221
35222
35223 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35224 PyObject *resultobj = 0;
35225 size_t arg1 = (size_t) 0 ;
35226 wxDisplay *result = 0 ;
35227 size_t val1 ;
35228 int ecode1 = 0 ;
35229 PyObject * obj0 = 0 ;
35230 char * kwnames[] = {
35231 (char *) "index", NULL
35232 };
35233
35234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35235 if (obj0) {
35236 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35237 if (!SWIG_IsOK(ecode1)) {
35238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35239 }
35240 arg1 = static_cast< size_t >(val1);
35241 }
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 result = (wxDisplay *)new wxDisplay(arg1);
35245 wxPyEndAllowThreads(__tstate);
35246 if (PyErr_Occurred()) SWIG_fail;
35247 }
35248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35249 return resultobj;
35250 fail:
35251 return NULL;
35252 }
35253
35254
35255 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35256 PyObject *resultobj = 0;
35257 wxDisplay *arg1 = (wxDisplay *) 0 ;
35258 void *argp1 = 0 ;
35259 int res1 = 0 ;
35260 PyObject *swig_obj[1] ;
35261
35262 if (!args) SWIG_fail;
35263 swig_obj[0] = args;
35264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35265 if (!SWIG_IsOK(res1)) {
35266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35267 }
35268 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35269 {
35270 PyThreadState* __tstate = wxPyBeginAllowThreads();
35271 delete arg1;
35272
35273 wxPyEndAllowThreads(__tstate);
35274 if (PyErr_Occurred()) SWIG_fail;
35275 }
35276 resultobj = SWIG_Py_Void();
35277 return resultobj;
35278 fail:
35279 return NULL;
35280 }
35281
35282
35283 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35284 PyObject *resultobj = 0;
35285 size_t result;
35286
35287 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35288 {
35289 PyThreadState* __tstate = wxPyBeginAllowThreads();
35290 result = (size_t)wxDisplay::GetCount();
35291 wxPyEndAllowThreads(__tstate);
35292 if (PyErr_Occurred()) SWIG_fail;
35293 }
35294 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35295 return resultobj;
35296 fail:
35297 return NULL;
35298 }
35299
35300
35301 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35302 PyObject *resultobj = 0;
35303 wxPoint *arg1 = 0 ;
35304 int result;
35305 wxPoint temp1 ;
35306 PyObject * obj0 = 0 ;
35307 char * kwnames[] = {
35308 (char *) "pt", NULL
35309 };
35310
35311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35312 {
35313 arg1 = &temp1;
35314 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35315 }
35316 {
35317 PyThreadState* __tstate = wxPyBeginAllowThreads();
35318 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 resultobj = SWIG_From_int(static_cast< int >(result));
35323 return resultobj;
35324 fail:
35325 return NULL;
35326 }
35327
35328
35329 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35330 PyObject *resultobj = 0;
35331 wxWindow *arg1 = (wxWindow *) 0 ;
35332 int result;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 PyObject * obj0 = 0 ;
35336 char * kwnames[] = {
35337 (char *) "window", NULL
35338 };
35339
35340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35342 if (!SWIG_IsOK(res1)) {
35343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35344 }
35345 arg1 = reinterpret_cast< wxWindow * >(argp1);
35346 {
35347 PyThreadState* __tstate = wxPyBeginAllowThreads();
35348 result = (int)wxDisplay::GetFromWindow(arg1);
35349 wxPyEndAllowThreads(__tstate);
35350 if (PyErr_Occurred()) SWIG_fail;
35351 }
35352 resultobj = SWIG_From_int(static_cast< int >(result));
35353 return resultobj;
35354 fail:
35355 return NULL;
35356 }
35357
35358
35359 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35360 PyObject *resultobj = 0;
35361 wxDisplay *arg1 = (wxDisplay *) 0 ;
35362 bool result;
35363 void *argp1 = 0 ;
35364 int res1 = 0 ;
35365 PyObject *swig_obj[1] ;
35366
35367 if (!args) SWIG_fail;
35368 swig_obj[0] = args;
35369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35370 if (!SWIG_IsOK(res1)) {
35371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35372 }
35373 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35374 {
35375 PyThreadState* __tstate = wxPyBeginAllowThreads();
35376 result = (bool)((wxDisplay const *)arg1)->IsOk();
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 {
35381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35382 }
35383 return resultobj;
35384 fail:
35385 return NULL;
35386 }
35387
35388
35389 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35390 PyObject *resultobj = 0;
35391 wxDisplay *arg1 = (wxDisplay *) 0 ;
35392 wxRect result;
35393 void *argp1 = 0 ;
35394 int res1 = 0 ;
35395 PyObject *swig_obj[1] ;
35396
35397 if (!args) SWIG_fail;
35398 swig_obj[0] = args;
35399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35400 if (!SWIG_IsOK(res1)) {
35401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35402 }
35403 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = ((wxDisplay const *)arg1)->GetGeometry();
35407 wxPyEndAllowThreads(__tstate);
35408 if (PyErr_Occurred()) SWIG_fail;
35409 }
35410 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35418 PyObject *resultobj = 0;
35419 wxDisplay *arg1 = (wxDisplay *) 0 ;
35420 wxRect result;
35421 void *argp1 = 0 ;
35422 int res1 = 0 ;
35423 PyObject *swig_obj[1] ;
35424
35425 if (!args) SWIG_fail;
35426 swig_obj[0] = args;
35427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35430 }
35431 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35432 {
35433 PyThreadState* __tstate = wxPyBeginAllowThreads();
35434 result = ((wxDisplay const *)arg1)->GetClientArea();
35435 wxPyEndAllowThreads(__tstate);
35436 if (PyErr_Occurred()) SWIG_fail;
35437 }
35438 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35439 return resultobj;
35440 fail:
35441 return NULL;
35442 }
35443
35444
35445 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35446 PyObject *resultobj = 0;
35447 wxDisplay *arg1 = (wxDisplay *) 0 ;
35448 wxString result;
35449 void *argp1 = 0 ;
35450 int res1 = 0 ;
35451 PyObject *swig_obj[1] ;
35452
35453 if (!args) SWIG_fail;
35454 swig_obj[0] = args;
35455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35456 if (!SWIG_IsOK(res1)) {
35457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35458 }
35459 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35460 {
35461 PyThreadState* __tstate = wxPyBeginAllowThreads();
35462 result = ((wxDisplay const *)arg1)->GetName();
35463 wxPyEndAllowThreads(__tstate);
35464 if (PyErr_Occurred()) SWIG_fail;
35465 }
35466 {
35467 #if wxUSE_UNICODE
35468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35469 #else
35470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35471 #endif
35472 }
35473 return resultobj;
35474 fail:
35475 return NULL;
35476 }
35477
35478
35479 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35480 PyObject *resultobj = 0;
35481 wxDisplay *arg1 = (wxDisplay *) 0 ;
35482 bool result;
35483 void *argp1 = 0 ;
35484 int res1 = 0 ;
35485 PyObject *swig_obj[1] ;
35486
35487 if (!args) SWIG_fail;
35488 swig_obj[0] = args;
35489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35490 if (!SWIG_IsOK(res1)) {
35491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35492 }
35493 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35494 {
35495 PyThreadState* __tstate = wxPyBeginAllowThreads();
35496 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35497 wxPyEndAllowThreads(__tstate);
35498 if (PyErr_Occurred()) SWIG_fail;
35499 }
35500 {
35501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35502 }
35503 return resultobj;
35504 fail:
35505 return NULL;
35506 }
35507
35508
35509 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35510 PyObject *resultobj = 0;
35511 wxDisplay *arg1 = (wxDisplay *) 0 ;
35512 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35513 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35514 PyObject *result = 0 ;
35515 void *argp1 = 0 ;
35516 int res1 = 0 ;
35517 void *argp2 = 0 ;
35518 int res2 = 0 ;
35519 PyObject * obj0 = 0 ;
35520 PyObject * obj1 = 0 ;
35521 char * kwnames[] = {
35522 (char *) "self",(char *) "mode", NULL
35523 };
35524
35525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35527 if (!SWIG_IsOK(res1)) {
35528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35529 }
35530 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35531 if (obj1) {
35532 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35533 if (!SWIG_IsOK(res2)) {
35534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35535 }
35536 if (!argp2) {
35537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35538 }
35539 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35540 }
35541 {
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35544 wxPyEndAllowThreads(__tstate);
35545 if (PyErr_Occurred()) SWIG_fail;
35546 }
35547 resultobj = result;
35548 return resultobj;
35549 fail:
35550 return NULL;
35551 }
35552
35553
35554 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35555 PyObject *resultobj = 0;
35556 wxDisplay *arg1 = (wxDisplay *) 0 ;
35557 wxVideoMode result;
35558 void *argp1 = 0 ;
35559 int res1 = 0 ;
35560 PyObject *swig_obj[1] ;
35561
35562 if (!args) SWIG_fail;
35563 swig_obj[0] = args;
35564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35565 if (!SWIG_IsOK(res1)) {
35566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35567 }
35568 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35569 {
35570 PyThreadState* __tstate = wxPyBeginAllowThreads();
35571 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35572 wxPyEndAllowThreads(__tstate);
35573 if (PyErr_Occurred()) SWIG_fail;
35574 }
35575 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35576 return resultobj;
35577 fail:
35578 return NULL;
35579 }
35580
35581
35582 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35583 PyObject *resultobj = 0;
35584 wxDisplay *arg1 = (wxDisplay *) 0 ;
35585 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35586 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35587 bool result;
35588 void *argp1 = 0 ;
35589 int res1 = 0 ;
35590 void *argp2 = 0 ;
35591 int res2 = 0 ;
35592 PyObject * obj0 = 0 ;
35593 PyObject * obj1 = 0 ;
35594 char * kwnames[] = {
35595 (char *) "self",(char *) "mode", NULL
35596 };
35597
35598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35600 if (!SWIG_IsOK(res1)) {
35601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35602 }
35603 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35604 if (obj1) {
35605 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35606 if (!SWIG_IsOK(res2)) {
35607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35608 }
35609 if (!argp2) {
35610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35611 }
35612 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35613 }
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 {
35621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35622 }
35623 return resultobj;
35624 fail:
35625 return NULL;
35626 }
35627
35628
35629 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35630 PyObject *resultobj = 0;
35631 wxDisplay *arg1 = (wxDisplay *) 0 ;
35632 void *argp1 = 0 ;
35633 int res1 = 0 ;
35634 PyObject *swig_obj[1] ;
35635
35636 if (!args) SWIG_fail;
35637 swig_obj[0] = args;
35638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35639 if (!SWIG_IsOK(res1)) {
35640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35641 }
35642 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35643 {
35644 PyThreadState* __tstate = wxPyBeginAllowThreads();
35645 wxDisplay_ResetMode(arg1);
35646 wxPyEndAllowThreads(__tstate);
35647 if (PyErr_Occurred()) SWIG_fail;
35648 }
35649 resultobj = SWIG_Py_Void();
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35657 PyObject *obj;
35658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35659 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35660 return SWIG_Py_Void();
35661 }
35662
35663 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35664 return SWIG_Python_InitShadowInstance(args);
35665 }
35666
35667 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35668 PyObject *resultobj = 0;
35669 wxStandardPaths *result = 0 ;
35670
35671 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35672 {
35673 PyThreadState* __tstate = wxPyBeginAllowThreads();
35674 result = (wxStandardPaths *)wxStandardPaths_Get();
35675 wxPyEndAllowThreads(__tstate);
35676 if (PyErr_Occurred()) SWIG_fail;
35677 }
35678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35679 return resultobj;
35680 fail:
35681 return NULL;
35682 }
35683
35684
35685 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35686 PyObject *resultobj = 0;
35687 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35688 wxString result;
35689 void *argp1 = 0 ;
35690 int res1 = 0 ;
35691 PyObject *swig_obj[1] ;
35692
35693 if (!args) SWIG_fail;
35694 swig_obj[0] = args;
35695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35696 if (!SWIG_IsOK(res1)) {
35697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35698 }
35699 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35700 {
35701 PyThreadState* __tstate = wxPyBeginAllowThreads();
35702 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35703 wxPyEndAllowThreads(__tstate);
35704 if (PyErr_Occurred()) SWIG_fail;
35705 }
35706 {
35707 #if wxUSE_UNICODE
35708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35709 #else
35710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35711 #endif
35712 }
35713 return resultobj;
35714 fail:
35715 return NULL;
35716 }
35717
35718
35719 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35720 PyObject *resultobj = 0;
35721 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35722 wxString result;
35723 void *argp1 = 0 ;
35724 int res1 = 0 ;
35725 PyObject *swig_obj[1] ;
35726
35727 if (!args) SWIG_fail;
35728 swig_obj[0] = args;
35729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35730 if (!SWIG_IsOK(res1)) {
35731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35732 }
35733 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35734 {
35735 PyThreadState* __tstate = wxPyBeginAllowThreads();
35736 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 {
35741 #if wxUSE_UNICODE
35742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35743 #else
35744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35745 #endif
35746 }
35747 return resultobj;
35748 fail:
35749 return NULL;
35750 }
35751
35752
35753 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35754 PyObject *resultobj = 0;
35755 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35756 wxString result;
35757 void *argp1 = 0 ;
35758 int res1 = 0 ;
35759 PyObject *swig_obj[1] ;
35760
35761 if (!args) SWIG_fail;
35762 swig_obj[0] = args;
35763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35764 if (!SWIG_IsOK(res1)) {
35765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35766 }
35767 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35768 {
35769 PyThreadState* __tstate = wxPyBeginAllowThreads();
35770 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35771 wxPyEndAllowThreads(__tstate);
35772 if (PyErr_Occurred()) SWIG_fail;
35773 }
35774 {
35775 #if wxUSE_UNICODE
35776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35777 #else
35778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35779 #endif
35780 }
35781 return resultobj;
35782 fail:
35783 return NULL;
35784 }
35785
35786
35787 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35788 PyObject *resultobj = 0;
35789 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35790 wxString result;
35791 void *argp1 = 0 ;
35792 int res1 = 0 ;
35793 PyObject *swig_obj[1] ;
35794
35795 if (!args) SWIG_fail;
35796 swig_obj[0] = args;
35797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35798 if (!SWIG_IsOK(res1)) {
35799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35800 }
35801 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35802 {
35803 PyThreadState* __tstate = wxPyBeginAllowThreads();
35804 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35805 wxPyEndAllowThreads(__tstate);
35806 if (PyErr_Occurred()) SWIG_fail;
35807 }
35808 {
35809 #if wxUSE_UNICODE
35810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35811 #else
35812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35813 #endif
35814 }
35815 return resultobj;
35816 fail:
35817 return NULL;
35818 }
35819
35820
35821 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35822 PyObject *resultobj = 0;
35823 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35824 wxString result;
35825 void *argp1 = 0 ;
35826 int res1 = 0 ;
35827 PyObject *swig_obj[1] ;
35828
35829 if (!args) SWIG_fail;
35830 swig_obj[0] = args;
35831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35832 if (!SWIG_IsOK(res1)) {
35833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35834 }
35835 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35836 {
35837 PyThreadState* __tstate = wxPyBeginAllowThreads();
35838 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35839 wxPyEndAllowThreads(__tstate);
35840 if (PyErr_Occurred()) SWIG_fail;
35841 }
35842 {
35843 #if wxUSE_UNICODE
35844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35845 #else
35846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35847 #endif
35848 }
35849 return resultobj;
35850 fail:
35851 return NULL;
35852 }
35853
35854
35855 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35856 PyObject *resultobj = 0;
35857 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35858 wxString result;
35859 void *argp1 = 0 ;
35860 int res1 = 0 ;
35861 PyObject *swig_obj[1] ;
35862
35863 if (!args) SWIG_fail;
35864 swig_obj[0] = args;
35865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35866 if (!SWIG_IsOK(res1)) {
35867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35868 }
35869 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35870 {
35871 PyThreadState* __tstate = wxPyBeginAllowThreads();
35872 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35873 wxPyEndAllowThreads(__tstate);
35874 if (PyErr_Occurred()) SWIG_fail;
35875 }
35876 {
35877 #if wxUSE_UNICODE
35878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35879 #else
35880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35881 #endif
35882 }
35883 return resultobj;
35884 fail:
35885 return NULL;
35886 }
35887
35888
35889 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35890 PyObject *resultobj = 0;
35891 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35892 wxString result;
35893 void *argp1 = 0 ;
35894 int res1 = 0 ;
35895 PyObject *swig_obj[1] ;
35896
35897 if (!args) SWIG_fail;
35898 swig_obj[0] = args;
35899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35900 if (!SWIG_IsOK(res1)) {
35901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35902 }
35903 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35907 wxPyEndAllowThreads(__tstate);
35908 if (PyErr_Occurred()) SWIG_fail;
35909 }
35910 {
35911 #if wxUSE_UNICODE
35912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35913 #else
35914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35915 #endif
35916 }
35917 return resultobj;
35918 fail:
35919 return NULL;
35920 }
35921
35922
35923 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35924 PyObject *resultobj = 0;
35925 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35926 wxString result;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 PyObject *swig_obj[1] ;
35930
35931 if (!args) SWIG_fail;
35932 swig_obj[0] = args;
35933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35934 if (!SWIG_IsOK(res1)) {
35935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35936 }
35937 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35938 {
35939 PyThreadState* __tstate = wxPyBeginAllowThreads();
35940 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35941 wxPyEndAllowThreads(__tstate);
35942 if (PyErr_Occurred()) SWIG_fail;
35943 }
35944 {
35945 #if wxUSE_UNICODE
35946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35947 #else
35948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35949 #endif
35950 }
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35958 PyObject *resultobj = 0;
35959 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35960 wxString *arg2 = 0 ;
35961 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35962 wxString result;
35963 void *argp1 = 0 ;
35964 int res1 = 0 ;
35965 bool temp2 = false ;
35966 int val3 ;
35967 int ecode3 = 0 ;
35968 PyObject * obj0 = 0 ;
35969 PyObject * obj1 = 0 ;
35970 PyObject * obj2 = 0 ;
35971 char * kwnames[] = {
35972 (char *) "self",(char *) "lang",(char *) "category", NULL
35973 };
35974
35975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35977 if (!SWIG_IsOK(res1)) {
35978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35979 }
35980 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35981 {
35982 arg2 = wxString_in_helper(obj1);
35983 if (arg2 == NULL) SWIG_fail;
35984 temp2 = true;
35985 }
35986 if (obj2) {
35987 ecode3 = SWIG_AsVal_int(obj2, &val3);
35988 if (!SWIG_IsOK(ecode3)) {
35989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35990 }
35991 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35992 }
35993 {
35994 PyThreadState* __tstate = wxPyBeginAllowThreads();
35995 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35996 wxPyEndAllowThreads(__tstate);
35997 if (PyErr_Occurred()) SWIG_fail;
35998 }
35999 {
36000 #if wxUSE_UNICODE
36001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36002 #else
36003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36004 #endif
36005 }
36006 {
36007 if (temp2)
36008 delete arg2;
36009 }
36010 return resultobj;
36011 fail:
36012 {
36013 if (temp2)
36014 delete arg2;
36015 }
36016 return NULL;
36017 }
36018
36019
36020 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36021 PyObject *resultobj = 0;
36022 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36023 wxString result;
36024 void *argp1 = 0 ;
36025 int res1 = 0 ;
36026 PyObject *swig_obj[1] ;
36027
36028 if (!args) SWIG_fail;
36029 swig_obj[0] = args;
36030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36031 if (!SWIG_IsOK(res1)) {
36032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36033 }
36034 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36035 {
36036 PyThreadState* __tstate = wxPyBeginAllowThreads();
36037 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
36038 wxPyEndAllowThreads(__tstate);
36039 if (PyErr_Occurred()) SWIG_fail;
36040 }
36041 {
36042 #if wxUSE_UNICODE
36043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36044 #else
36045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36046 #endif
36047 }
36048 return resultobj;
36049 fail:
36050 return NULL;
36051 }
36052
36053
36054 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36055 PyObject *resultobj = 0;
36056 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36057 wxString *arg2 = 0 ;
36058 void *argp1 = 0 ;
36059 int res1 = 0 ;
36060 bool temp2 = false ;
36061 PyObject * obj0 = 0 ;
36062 PyObject * obj1 = 0 ;
36063 char * kwnames[] = {
36064 (char *) "self",(char *) "prefix", NULL
36065 };
36066
36067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
36068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36069 if (!SWIG_IsOK(res1)) {
36070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36071 }
36072 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36073 {
36074 arg2 = wxString_in_helper(obj1);
36075 if (arg2 == NULL) SWIG_fail;
36076 temp2 = true;
36077 }
36078 {
36079 PyThreadState* __tstate = wxPyBeginAllowThreads();
36080 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
36081 wxPyEndAllowThreads(__tstate);
36082 if (PyErr_Occurred()) SWIG_fail;
36083 }
36084 resultobj = SWIG_Py_Void();
36085 {
36086 if (temp2)
36087 delete arg2;
36088 }
36089 return resultobj;
36090 fail:
36091 {
36092 if (temp2)
36093 delete arg2;
36094 }
36095 return NULL;
36096 }
36097
36098
36099 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36100 PyObject *resultobj = 0;
36101 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36102 wxString result;
36103 void *argp1 = 0 ;
36104 int res1 = 0 ;
36105 PyObject *swig_obj[1] ;
36106
36107 if (!args) SWIG_fail;
36108 swig_obj[0] = args;
36109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36110 if (!SWIG_IsOK(res1)) {
36111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36112 }
36113 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36114 {
36115 PyThreadState* __tstate = wxPyBeginAllowThreads();
36116 result = wxStandardPaths_GetInstallPrefix(arg1);
36117 wxPyEndAllowThreads(__tstate);
36118 if (PyErr_Occurred()) SWIG_fail;
36119 }
36120 {
36121 #if wxUSE_UNICODE
36122 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36123 #else
36124 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36125 #endif
36126 }
36127 return resultobj;
36128 fail:
36129 return NULL;
36130 }
36131
36132
36133 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36134 PyObject *obj;
36135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36136 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36137 return SWIG_Py_Void();
36138 }
36139
36140 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36141 PyObject *resultobj = 0;
36142 wxEventType arg1 ;
36143 wxPowerEvent *result = 0 ;
36144 int val1 ;
36145 int ecode1 = 0 ;
36146 PyObject * obj0 = 0 ;
36147 char * kwnames[] = {
36148 (char *) "evtType", NULL
36149 };
36150
36151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36152 ecode1 = SWIG_AsVal_int(obj0, &val1);
36153 if (!SWIG_IsOK(ecode1)) {
36154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36155 }
36156 arg1 = static_cast< wxEventType >(val1);
36157 {
36158 PyThreadState* __tstate = wxPyBeginAllowThreads();
36159 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36160 wxPyEndAllowThreads(__tstate);
36161 if (PyErr_Occurred()) SWIG_fail;
36162 }
36163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36164 return resultobj;
36165 fail:
36166 return NULL;
36167 }
36168
36169
36170 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36171 PyObject *resultobj = 0;
36172 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36173 void *argp1 = 0 ;
36174 int res1 = 0 ;
36175 PyObject *swig_obj[1] ;
36176
36177 if (!args) SWIG_fail;
36178 swig_obj[0] = args;
36179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36182 }
36183 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36184 {
36185 PyThreadState* __tstate = wxPyBeginAllowThreads();
36186 (arg1)->Veto();
36187 wxPyEndAllowThreads(__tstate);
36188 if (PyErr_Occurred()) SWIG_fail;
36189 }
36190 resultobj = SWIG_Py_Void();
36191 return resultobj;
36192 fail:
36193 return NULL;
36194 }
36195
36196
36197 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36198 PyObject *resultobj = 0;
36199 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36200 bool result;
36201 void *argp1 = 0 ;
36202 int res1 = 0 ;
36203 PyObject *swig_obj[1] ;
36204
36205 if (!args) SWIG_fail;
36206 swig_obj[0] = args;
36207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36208 if (!SWIG_IsOK(res1)) {
36209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36210 }
36211 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36212 {
36213 PyThreadState* __tstate = wxPyBeginAllowThreads();
36214 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36215 wxPyEndAllowThreads(__tstate);
36216 if (PyErr_Occurred()) SWIG_fail;
36217 }
36218 {
36219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36220 }
36221 return resultobj;
36222 fail:
36223 return NULL;
36224 }
36225
36226
36227 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36228 PyObject *obj;
36229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36230 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36231 return SWIG_Py_Void();
36232 }
36233
36234 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36235 return SWIG_Python_InitShadowInstance(args);
36236 }
36237
36238 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36239 PyObject *resultobj = 0;
36240 wxPowerType result;
36241
36242 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36243 {
36244 PyThreadState* __tstate = wxPyBeginAllowThreads();
36245 result = (wxPowerType)wxGetPowerType();
36246 wxPyEndAllowThreads(__tstate);
36247 if (PyErr_Occurred()) SWIG_fail;
36248 }
36249 resultobj = SWIG_From_int(static_cast< int >(result));
36250 return resultobj;
36251 fail:
36252 return NULL;
36253 }
36254
36255
36256 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36257 PyObject *resultobj = 0;
36258 wxBatteryState result;
36259
36260 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 result = (wxBatteryState)wxGetBatteryState();
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 resultobj = SWIG_From_int(static_cast< int >(result));
36268 return resultobj;
36269 fail:
36270 return NULL;
36271 }
36272
36273
36274 static PyMethodDef SwigMethods[] = {
36275 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36277 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36280 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36281 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36282 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36283 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36289 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36290 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36291 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36292 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36293 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36294 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36295 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36296 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36297 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36298 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36299 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36301 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36302 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36304 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36305 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36306 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36307 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36309 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36310 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36314 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36315 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36316 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36317 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36318 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36319 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36321 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36322 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36326 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36331 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36332 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36333 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36334 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36335 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36336 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36337 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36338 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36339 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36340 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36341 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36343 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36345 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36346 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36347 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36349 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36350 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36351 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36352 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36353 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36354 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36355 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36356 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36357 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36358 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36359 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36360 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36361 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36362 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36363 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36364 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36371 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36374 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36375 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36376 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36377 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36378 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36379 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36380 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36381 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36382 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36383 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36384 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36386 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36387 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36388 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36389 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36392 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36393 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36395 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36396 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36397 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36398 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36399 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36400 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36401 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36402 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36403 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36409 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36410 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36411 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36412 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36413 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36414 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36415 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36416 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36417 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36419 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36420 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36421 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36423 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36424 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36425 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36426 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36428 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36429 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36430 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36431 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36432 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36434 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36436 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36437 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36438 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36440 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36442 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36444 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36445 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36446 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36447 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36448 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36449 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36450 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36451 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36452 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36453 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36454 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36455 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36456 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36457 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36458 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36460 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36463 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36464 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36468 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36471 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36473 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36474 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36475 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36476 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36477 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36478 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36479 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36480 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36481 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36482 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36483 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36484 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36485 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36486 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36488 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36489 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36490 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36491 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36492 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36495 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36496 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36497 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36499 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36500 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36501 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36502 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36503 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36504 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36505 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36506 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36507 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36508 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36510 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36511 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36513 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36514 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36515 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36516 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36517 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36518 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36519 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36520 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36521 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36523 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36524 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36525 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36526 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36527 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36530 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36531 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36532 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36534 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36535 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36539 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36540 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36541 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36542 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36543 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36544 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36545 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36546 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36547 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36560 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36561 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36562 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36563 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36564 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36565 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36566 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36568 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36569 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36573 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36576 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36577 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36578 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36579 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36580 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36581 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36582 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36583 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36584 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36585 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36586 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36587 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36589 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36590 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36591 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36592 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36593 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36594 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36595 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36596 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36600 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36601 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36602 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36603 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36604 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36605 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36606 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36607 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36608 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36609 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36611 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36612 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36613 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36614 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36615 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36616 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36617 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36618 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36619 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36620 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36621 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36622 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36623 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36624 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36625 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36626 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36627 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36628 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36629 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36630 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36631 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36632 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36633 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36634 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36635 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36636 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36637 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36638 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36639 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36640 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36642 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36643 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36644 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36646 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36647 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36648 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36649 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36650 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36656 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36657 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36658 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36659 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36661 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36662 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36663 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36666 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36669 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36670 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36672 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36673 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36674 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36676 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36677 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36678 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36679 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36680 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36681 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36682 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36683 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36684 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36685 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36686 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36687 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36688 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36689 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36690 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36691 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36692 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36693 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36694 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36695 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36696 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36697 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36698 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36699 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36700 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36705 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36707 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36708 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36710 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36712 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36716 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36717 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36718 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36719 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36720 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36721 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36722 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36723 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36724 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36725 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36727 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36728 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36733 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36734 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36735 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36736 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36737 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36738 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36739 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36740 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36742 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36743 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36745 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36763 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36765 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36766 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36768 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36770 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36771 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36772 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36773 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36775 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36777 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36778 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36780 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36781 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36782 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36783 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36784 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36785 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36786 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36788 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36789 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36790 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36791 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36794 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36805 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36809 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36810 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36811 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36812 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36814 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36818 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36819 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36824 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36825 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36826 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36827 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36834 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36838 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36841 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36842 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36843 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36844 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36845 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36846 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36847 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36848 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36849 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36850 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36851 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36852 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36854 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36857 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36858 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36864 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36865 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36866 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36871 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36872 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36874 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36875 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36877 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36878 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36881 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36882 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36883 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36885 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36886 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36889 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36891 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36892 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36893 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36894 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36896 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36898 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36900 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36902 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36903 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36904 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36905 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36906 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36907 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36908 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36909 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36910 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36911 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36912 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36913 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36914 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36915 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36916 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36917 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36918 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36919 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36920 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36922 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36923 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36924 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36926 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36927 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36928 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36929 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36930 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36931 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36933 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36935 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36936 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36938 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36939 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36940 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36941 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36942 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36943 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36944 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36945 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36946 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36947 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36948 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36949 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36950 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36951 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36952 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36953 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36954 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36955 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36956 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36957 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36958 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36959 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36960 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36961 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36962 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36963 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36964 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36965 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36966 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36967 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36968 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36969 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36970 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36971 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36972 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36973 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36974 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36975 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36976 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36977 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36978 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36979 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36980 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36982 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36983 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36984 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36985 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36986 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36988 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36989 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36990 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36991 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36992 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36993 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36994 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36995 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36996 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36997 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36998 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36999 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37000 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37001 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
37002 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
37003 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
37004 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
37005 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
37006 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
37007 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
37008 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
37009 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
37010 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
37011 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37012 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
37013 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37014 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
37015 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
37016 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
37017 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37018 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
37019 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37020 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
37021 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37022 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
37023 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
37024 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37025 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
37026 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
37027 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37028 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37029 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
37030 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
37031 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
37032 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37033 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
37034 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
37035 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
37036 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37037 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
37038 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
37039 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
37040 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
37041 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
37042 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37043 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37044 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
37045 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
37046 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37047 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
37048 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37049 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
37050 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
37051 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37052 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37053 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
37054 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
37055 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
37056 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
37057 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
37058 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
37059 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
37060 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
37061 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37062 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
37063 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
37064 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
37065 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
37066 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
37067 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
37068 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
37069 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
37070 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
37071 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
37072 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
37073 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
37074 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
37075 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
37076 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
37077 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
37078 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37079 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
37080 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37081 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
37082 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37083 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37084 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
37085 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
37086 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
37087 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37088 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37089 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
37090 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
37091 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37092 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37093 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37094 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
37095 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37096 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
37097 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
37098 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
37099 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
37100 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
37101 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
37102 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37103 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
37104 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37105 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37106 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
37107 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37108 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37109 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
37110 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
37111 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
37112 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37113 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
37114 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37115 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37116 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
37117 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37118 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37119 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
37120 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
37121 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
37122 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
37123 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
37124 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
37125 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
37126 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
37127 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37128 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37129 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37130 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37131 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37132 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37133 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37134 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37135 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37136 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37137 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37138 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37139 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37140 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37141 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37142 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37143 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37144 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37145 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37146 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37147 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37148 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37149 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37150 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37151 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37152 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37153 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37154 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37155 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37156 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37157 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37158 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37159 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37160 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37161 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37162 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37163 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37164 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37165 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37166 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37167 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37168 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37169 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37170 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37171 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37172 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37173 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37174 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37175 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37176 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37177 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37178 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37179 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37180 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37181 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37182 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37183 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37184 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37185 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37186 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37187 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37188 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37189 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37190 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37191 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37192 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37193 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37194 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37195 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37196 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37197 { NULL, NULL, 0, NULL }
37198 };
37199
37200
37201 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37202
37203 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37204 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37205 }
37206 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37207 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37208 }
37209 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37210 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37211 }
37212 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37213 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37214 }
37215 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37216 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37217 }
37218 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37219 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37220 }
37221 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37222 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37223 }
37224 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37225 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37226 }
37227 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37228 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37229 }
37230 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37231 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37232 }
37233 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37234 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37235 }
37236 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37237 return (void *)((wxEvent *) ((wxPyEvent *) x));
37238 }
37239 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37240 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37241 }
37242 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37243 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37244 }
37245 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37246 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37247 }
37248 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37249 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37250 }
37251 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37252 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37253 }
37254 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37255 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37256 }
37257 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37258 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37259 }
37260 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37261 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37262 }
37263 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37264 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37265 }
37266 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37267 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37268 }
37269 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37270 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37271 }
37272 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37273 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37274 }
37275 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37276 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37277 }
37278 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37280 }
37281 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37282 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37283 }
37284 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37285 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37286 }
37287 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37288 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37289 }
37290 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37291 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37292 }
37293 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37294 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37295 }
37296 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37297 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37298 }
37299 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37301 }
37302 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37303 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37304 }
37305 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37306 return (void *)((wxEvent *) ((wxShowEvent *) x));
37307 }
37308 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37309 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37310 }
37311 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37312 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37313 }
37314 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37315 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37316 }
37317 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37318 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37319 }
37320 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37321 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37322 }
37323 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37324 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37325 }
37326 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37327 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37328 }
37329 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37330 return (void *)((wxConfigBase *) ((wxConfig *) x));
37331 }
37332 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37333 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37334 }
37335 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37336 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37337 }
37338 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37339 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37340 }
37341 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37342 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37343 }
37344 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37345 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37346 }
37347 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37348 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37349 }
37350 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37351 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37352 }
37353 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37354 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37355 }
37356 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37357 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37358 }
37359 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37360 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37361 }
37362 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37363 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37364 }
37365 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37366 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37367 }
37368 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37369 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37370 }
37371 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37372 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37373 }
37374 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37375 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37376 }
37377 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37378 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37379 }
37380 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37381 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37382 }
37383 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37384 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37385 }
37386 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37387 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37388 }
37389 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37390 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37391 }
37392 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37393 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37394 }
37395 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37396 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37397 }
37398 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37399 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37400 }
37401 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37402 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37403 }
37404 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37405 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37406 }
37407 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37408 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37409 }
37410 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37411 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37412 }
37413 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37414 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37415 }
37416 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37417 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37418 }
37419 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37420 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37421 }
37422 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37423 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37424 }
37425 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37426 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37427 }
37428 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37429 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37430 }
37431 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37432 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37433 }
37434 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37435 return (void *)((wxObject *) ((wxSizerItem *) x));
37436 }
37437 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37438 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37439 }
37440 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37441 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37442 }
37443 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37444 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37445 }
37446 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37447 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37448 }
37449 static void *_p_wxSizerTo_p_wxObject(void *x) {
37450 return (void *)((wxObject *) ((wxSizer *) x));
37451 }
37452 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37453 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37454 }
37455 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37456 return (void *)((wxObject *) ((wxFileHistory *) x));
37457 }
37458 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37459 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37460 }
37461 static void *_p_wxEventTo_p_wxObject(void *x) {
37462 return (void *)((wxObject *) ((wxEvent *) x));
37463 }
37464 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37465 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37466 }
37467 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37468 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37469 }
37470 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37471 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37472 }
37473 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37474 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37475 }
37476 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37477 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37478 }
37479 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37480 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37481 }
37482 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37483 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37484 }
37485 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37486 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37487 }
37488 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37489 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37490 }
37491 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37492 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37493 }
37494 static void *_p_wxControlTo_p_wxObject(void *x) {
37495 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37496 }
37497 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37498 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37499 }
37500 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37501 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37502 }
37503 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37504 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37505 }
37506 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37507 return (void *)((wxObject *) ((wxFSFile *) x));
37508 }
37509 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37510 return (void *)((wxObject *) ((wxClipboard *) x));
37511 }
37512 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37513 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37514 }
37515 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37516 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37517 }
37518 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37519 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37520 }
37521 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37522 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37523 }
37524 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37525 return (void *)((wxObject *) ((wxToolTip *) x));
37526 }
37527 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37528 return (void *)((wxObject *) ((wxMenuItem *) x));
37529 }
37530 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37532 }
37533 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37534 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37535 }
37536 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37537 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37538 }
37539 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37540 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37541 }
37542 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37543 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37544 }
37545 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37546 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37547 }
37548 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37549 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37550 }
37551 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37552 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37553 }
37554 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37555 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37556 }
37557 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37558 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37559 }
37560 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37561 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37562 }
37563 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37564 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37565 }
37566 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37567 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37568 }
37569 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37570 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37571 }
37572 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37573 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37574 }
37575 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37576 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37577 }
37578 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37579 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37580 }
37581 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37582 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37583 }
37584 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37585 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37586 }
37587 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37588 return (void *)((wxObject *) ((wxImageHandler *) x));
37589 }
37590 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37591 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37592 }
37593 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37594 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37595 }
37596 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37597 return (void *)((wxObject *) ((wxEvtHandler *) x));
37598 }
37599 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37600 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37601 }
37602 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37603 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37604 }
37605 static void *_p_wxImageTo_p_wxObject(void *x) {
37606 return (void *)((wxObject *) ((wxImage *) x));
37607 }
37608 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37609 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37610 }
37611 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37612 return (void *)((wxObject *) ((wxSystemOptions *) x));
37613 }
37614 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37615 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37616 }
37617 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37619 }
37620 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37621 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37622 }
37623 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37624 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37625 }
37626 static void *_p_wxWindowTo_p_wxObject(void *x) {
37627 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37628 }
37629 static void *_p_wxMenuTo_p_wxObject(void *x) {
37630 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37631 }
37632 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37633 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37634 }
37635 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37636 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37637 }
37638 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37639 return (void *)((wxObject *) ((wxFileSystem *) x));
37640 }
37641 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37643 }
37644 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37645 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37646 }
37647 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37648 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37649 }
37650 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37651 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37652 }
37653 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37654 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37655 }
37656 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37657 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37658 }
37659 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37660 return (void *)((wxObject *) ((wxBusyInfo *) x));
37661 }
37662 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37663 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37664 }
37665 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37666 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37667 }
37668 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37669 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37670 }
37671 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37672 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37673 }
37674 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37675 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37676 }
37677 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37678 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37679 }
37680 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37681 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37682 }
37683 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37684 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37685 }
37686 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37687 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37688 }
37689 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37690 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37691 }
37692 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37693 return (void *)((wxLog *) ((wxLogBuffer *) x));
37694 }
37695 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37696 return (void *)((wxLog *) ((wxLogStderr *) x));
37697 }
37698 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37699 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37700 }
37701 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37702 return (void *)((wxLog *) ((wxLogWindow *) x));
37703 }
37704 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37705 return (void *)((wxLog *) ((wxLogChain *) x));
37706 }
37707 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37708 return (void *)((wxLog *) ((wxLogGui *) x));
37709 }
37710 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37711 return (void *)((wxLog *) ((wxPyLog *) x));
37712 }
37713 static void *_p_wxControlTo_p_wxWindow(void *x) {
37714 return (void *)((wxWindow *) ((wxControl *) x));
37715 }
37716 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37717 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37718 }
37719 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37720 return (void *)((wxWindow *) ((wxMenuBar *) x));
37721 }
37722 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37723 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37724 }
37725 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37726 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37727 }
37728 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37729 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};
37730 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37731 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37732 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37733 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37734 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37735 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37736 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37737 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37738 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37739 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37740 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37741 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37742 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37743 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37744 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37745 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37746 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37747 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37748 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37749 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37750 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37751 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37752 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37753 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37754 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37755 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37756 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37757 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37758 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37759 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37760 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37761 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37762 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37763 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37764 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37765 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37766 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37767 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37768 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37769 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37770 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37771 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37772 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37773 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37774 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37775 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37776 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37777 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37778 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37779 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37780 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37781 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37782 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37783 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37784 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37785 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37786 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37787 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37788 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37789 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37790 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37791 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37792 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37793 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37794 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37795 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37796 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37797 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37798 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37799 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37800 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37801 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37802 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37803 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37804 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37805 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37806 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37807 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37808 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37809 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37810 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37811 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37812 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37813 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37814 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37815 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37816 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37817 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37818 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37819 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37820 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37821 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37822 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37823 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37824 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37825 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37826 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37827 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37828 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37829 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37830 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37831 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37832 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37833 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37834 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37835 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37836 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37837 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37838 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37839 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37840 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37841 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37842 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37843 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37844 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37845 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37846 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37847 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37848 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37849 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37850 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37851 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37852 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37853 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37854 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37855 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37856 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37857 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37858 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37859 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37860 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37861 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37862 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37863 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37864 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37865 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37866 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37867 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37868 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37869 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37870 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37871 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37872 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37873 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37874 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37875 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37876 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37877 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37878 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37879 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37880 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37881 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37882 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37883 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37884 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37885 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37886 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37887 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37888 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37889 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37890 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37891 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37892 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37893 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37894 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37895 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37896 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37897 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37898 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37899
37900 static swig_type_info *swig_type_initial[] = {
37901 &_swigt__p_char,
37902 &_swigt__p_form_ops_t,
37903 &_swigt__p_int,
37904 &_swigt__p_unsigned_char,
37905 &_swigt__p_unsigned_int,
37906 &_swigt__p_unsigned_long,
37907 &_swigt__p_void,
37908 &_swigt__p_wxANIHandler,
37909 &_swigt__p_wxAcceleratorTable,
37910 &_swigt__p_wxActivateEvent,
37911 &_swigt__p_wxArrayString,
37912 &_swigt__p_wxBMPHandler,
37913 &_swigt__p_wxBitmap,
37914 &_swigt__p_wxBitmapDataObject,
37915 &_swigt__p_wxBoxSizer,
37916 &_swigt__p_wxBusyCursor,
37917 &_swigt__p_wxBusyInfo,
37918 &_swigt__p_wxCURHandler,
37919 &_swigt__p_wxCaret,
37920 &_swigt__p_wxChar,
37921 &_swigt__p_wxChildFocusEvent,
37922 &_swigt__p_wxClipboard,
37923 &_swigt__p_wxClipboardLocker,
37924 &_swigt__p_wxClipboardTextEvent,
37925 &_swigt__p_wxCloseEvent,
37926 &_swigt__p_wxColour,
37927 &_swigt__p_wxCommandEvent,
37928 &_swigt__p_wxConfig,
37929 &_swigt__p_wxConfigBase,
37930 &_swigt__p_wxConfigPathChanger,
37931 &_swigt__p_wxContextMenuEvent,
37932 &_swigt__p_wxControl,
37933 &_swigt__p_wxControlWithItems,
37934 &_swigt__p_wxCursor,
37935 &_swigt__p_wxCustomDataObject,
37936 &_swigt__p_wxDC,
37937 &_swigt__p_wxDataFormat,
37938 &_swigt__p_wxDataObject,
37939 &_swigt__p_wxDataObjectComposite,
37940 &_swigt__p_wxDataObjectSimple,
37941 &_swigt__p_wxDateEvent,
37942 &_swigt__p_wxDateSpan,
37943 &_swigt__p_wxDateTime,
37944 &_swigt__p_wxDateTime__TimeZone,
37945 &_swigt__p_wxDisplay,
37946 &_swigt__p_wxDisplayChangedEvent,
37947 &_swigt__p_wxDropFilesEvent,
37948 &_swigt__p_wxDuplexMode,
37949 &_swigt__p_wxEraseEvent,
37950 &_swigt__p_wxEvent,
37951 &_swigt__p_wxEvtHandler,
37952 &_swigt__p_wxFSFile,
37953 &_swigt__p_wxFileConfig,
37954 &_swigt__p_wxFileDataObject,
37955 &_swigt__p_wxFileHistory,
37956 &_swigt__p_wxFileSystem,
37957 &_swigt__p_wxFileType,
37958 &_swigt__p_wxFileTypeInfo,
37959 &_swigt__p_wxFlexGridSizer,
37960 &_swigt__p_wxFocusEvent,
37961 &_swigt__p_wxFont,
37962 &_swigt__p_wxFrame,
37963 &_swigt__p_wxGBSizerItem,
37964 &_swigt__p_wxGIFHandler,
37965 &_swigt__p_wxGridBagSizer,
37966 &_swigt__p_wxGridSizer,
37967 &_swigt__p_wxICOHandler,
37968 &_swigt__p_wxIcon,
37969 &_swigt__p_wxIconizeEvent,
37970 &_swigt__p_wxIdleEvent,
37971 &_swigt__p_wxImage,
37972 &_swigt__p_wxImageHandler,
37973 &_swigt__p_wxIndividualLayoutConstraint,
37974 &_swigt__p_wxInitDialogEvent,
37975 &_swigt__p_wxJPEGHandler,
37976 &_swigt__p_wxJoystick,
37977 &_swigt__p_wxJoystickEvent,
37978 &_swigt__p_wxKeyEvent,
37979 &_swigt__p_wxKillError,
37980 &_swigt__p_wxLayoutConstraints,
37981 &_swigt__p_wxLog,
37982 &_swigt__p_wxLogBuffer,
37983 &_swigt__p_wxLogChain,
37984 &_swigt__p_wxLogGui,
37985 &_swigt__p_wxLogNull,
37986 &_swigt__p_wxLogStderr,
37987 &_swigt__p_wxLogTextCtrl,
37988 &_swigt__p_wxLogWindow,
37989 &_swigt__p_wxMaximizeEvent,
37990 &_swigt__p_wxMenu,
37991 &_swigt__p_wxMenuBar,
37992 &_swigt__p_wxMenuEvent,
37993 &_swigt__p_wxMenuItem,
37994 &_swigt__p_wxMetafile,
37995 &_swigt__p_wxMetafileDataObject,
37996 &_swigt__p_wxMimeTypesManager,
37997 &_swigt__p_wxMouseCaptureChangedEvent,
37998 &_swigt__p_wxMouseEvent,
37999 &_swigt__p_wxMouseState,
38000 &_swigt__p_wxMoveEvent,
38001 &_swigt__p_wxMutexGuiLocker,
38002 &_swigt__p_wxNavigationKeyEvent,
38003 &_swigt__p_wxNcPaintEvent,
38004 &_swigt__p_wxNotifyEvent,
38005 &_swigt__p_wxObject,
38006 &_swigt__p_wxOutputStream,
38007 &_swigt__p_wxPCXHandler,
38008 &_swigt__p_wxPNGHandler,
38009 &_swigt__p_wxPNMHandler,
38010 &_swigt__p_wxPaintEvent,
38011 &_swigt__p_wxPaletteChangedEvent,
38012 &_swigt__p_wxPaperSize,
38013 &_swigt__p_wxPoint,
38014 &_swigt__p_wxPowerEvent,
38015 &_swigt__p_wxProcessEvent,
38016 &_swigt__p_wxPyApp,
38017 &_swigt__p_wxPyArtProvider,
38018 &_swigt__p_wxPyBitmapDataObject,
38019 &_swigt__p_wxPyCommandEvent,
38020 &_swigt__p_wxPyDataObjectSimple,
38021 &_swigt__p_wxPyDropSource,
38022 &_swigt__p_wxPyDropTarget,
38023 &_swigt__p_wxPyEvent,
38024 &_swigt__p_wxPyFileDropTarget,
38025 &_swigt__p_wxPyImageHandler,
38026 &_swigt__p_wxPyLog,
38027 &_swigt__p_wxPyProcess,
38028 &_swigt__p_wxPySizer,
38029 &_swigt__p_wxPyTextDataObject,
38030 &_swigt__p_wxPyTextDropTarget,
38031 &_swigt__p_wxPyTimer,
38032 &_swigt__p_wxPyTipProvider,
38033 &_swigt__p_wxPyValidator,
38034 &_swigt__p_wxQueryNewPaletteEvent,
38035 &_swigt__p_wxRect,
38036 &_swigt__p_wxScrollEvent,
38037 &_swigt__p_wxScrollWinEvent,
38038 &_swigt__p_wxSetCursorEvent,
38039 &_swigt__p_wxShowEvent,
38040 &_swigt__p_wxSingleInstanceChecker,
38041 &_swigt__p_wxSize,
38042 &_swigt__p_wxSizeEvent,
38043 &_swigt__p_wxSizer,
38044 &_swigt__p_wxSizerItem,
38045 &_swigt__p_wxSound,
38046 &_swigt__p_wxStandardPaths,
38047 &_swigt__p_wxStaticBoxSizer,
38048 &_swigt__p_wxStdDialogButtonSizer,
38049 &_swigt__p_wxStopWatch,
38050 &_swigt__p_wxString,
38051 &_swigt__p_wxSysColourChangedEvent,
38052 &_swigt__p_wxSystemOptions,
38053 &_swigt__p_wxSystemSettings,
38054 &_swigt__p_wxTIFFHandler,
38055 &_swigt__p_wxTextCtrl,
38056 &_swigt__p_wxTextDataObject,
38057 &_swigt__p_wxTimeSpan,
38058 &_swigt__p_wxTimer,
38059 &_swigt__p_wxTimerEvent,
38060 &_swigt__p_wxTimerRunner,
38061 &_swigt__p_wxTipProvider,
38062 &_swigt__p_wxToolTip,
38063 &_swigt__p_wxURLDataObject,
38064 &_swigt__p_wxUpdateUIEvent,
38065 &_swigt__p_wxValidator,
38066 &_swigt__p_wxVideoMode,
38067 &_swigt__p_wxWindow,
38068 &_swigt__p_wxWindowCreateEvent,
38069 &_swigt__p_wxWindowDestroyEvent,
38070 &_swigt__p_wxWindowDisabler,
38071 &_swigt__p_wxXPMHandler,
38072 };
38073
38074 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
38075 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
38076 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
38077 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
38078 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
38079 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
38080 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
38081 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
38082 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
38083 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}};
38084 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
38085 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
38086 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
38087 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
38088 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
38089 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
38090 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
38091 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
38092 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}};
38093 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
38094 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
38095 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
38096 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
38097 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
38098 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}};
38099 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
38100 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}};
38101 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
38102 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
38103 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
38104 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
38105 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
38106 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38107 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38108 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
38109 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
38110 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
38111 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
38112 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
38113 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
38114 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
38115 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
38116 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
38117 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
38118 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
38119 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38120 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38121 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
38122 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38123 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
38124 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
38125 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38126 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38127 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38128 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38129 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38130 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38131 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38132 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38133 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38134 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38135 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38136 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38137 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38138 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38139 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38140 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38141 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38142 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38143 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}};
38144 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38145 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38146 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38147 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38148 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38149 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38150 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}};
38151 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38152 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38153 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38154 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38155 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38156 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38157 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38158 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38159 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38160 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38161 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38162 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}};
38163 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38164 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38165 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38166 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38167 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38168 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38169 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38170 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38171 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
38172 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38173 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38174 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38175 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38176 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38177 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38178 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38179 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38180 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38181 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38182 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38183 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38184 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38185 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38186 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38187 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38188 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38189 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38190 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38191 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38192 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38193 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38194 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38195 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38196 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38197 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38198 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38199 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38200 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38201 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38202 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38203 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38204 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38205 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38206 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}};
38207 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38208 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38209 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38210 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38211 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38212 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38213 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38214 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38215 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38216 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}};
38217 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38218 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38219 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38220 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38221 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38222 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38223 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38224 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38225 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38226 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38227 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38228 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38229 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38230 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38231 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38232 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38233 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38234 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}};
38235 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38236 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38237 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38238 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38239 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}};
38240 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38241 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38242 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38243 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}};
38244 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38245
38246 static swig_cast_info *swig_cast_initial[] = {
38247 _swigc__p_char,
38248 _swigc__p_form_ops_t,
38249 _swigc__p_int,
38250 _swigc__p_unsigned_char,
38251 _swigc__p_unsigned_int,
38252 _swigc__p_unsigned_long,
38253 _swigc__p_void,
38254 _swigc__p_wxANIHandler,
38255 _swigc__p_wxAcceleratorTable,
38256 _swigc__p_wxActivateEvent,
38257 _swigc__p_wxArrayString,
38258 _swigc__p_wxBMPHandler,
38259 _swigc__p_wxBitmap,
38260 _swigc__p_wxBitmapDataObject,
38261 _swigc__p_wxBoxSizer,
38262 _swigc__p_wxBusyCursor,
38263 _swigc__p_wxBusyInfo,
38264 _swigc__p_wxCURHandler,
38265 _swigc__p_wxCaret,
38266 _swigc__p_wxChar,
38267 _swigc__p_wxChildFocusEvent,
38268 _swigc__p_wxClipboard,
38269 _swigc__p_wxClipboardLocker,
38270 _swigc__p_wxClipboardTextEvent,
38271 _swigc__p_wxCloseEvent,
38272 _swigc__p_wxColour,
38273 _swigc__p_wxCommandEvent,
38274 _swigc__p_wxConfig,
38275 _swigc__p_wxConfigBase,
38276 _swigc__p_wxConfigPathChanger,
38277 _swigc__p_wxContextMenuEvent,
38278 _swigc__p_wxControl,
38279 _swigc__p_wxControlWithItems,
38280 _swigc__p_wxCursor,
38281 _swigc__p_wxCustomDataObject,
38282 _swigc__p_wxDC,
38283 _swigc__p_wxDataFormat,
38284 _swigc__p_wxDataObject,
38285 _swigc__p_wxDataObjectComposite,
38286 _swigc__p_wxDataObjectSimple,
38287 _swigc__p_wxDateEvent,
38288 _swigc__p_wxDateSpan,
38289 _swigc__p_wxDateTime,
38290 _swigc__p_wxDateTime__TimeZone,
38291 _swigc__p_wxDisplay,
38292 _swigc__p_wxDisplayChangedEvent,
38293 _swigc__p_wxDropFilesEvent,
38294 _swigc__p_wxDuplexMode,
38295 _swigc__p_wxEraseEvent,
38296 _swigc__p_wxEvent,
38297 _swigc__p_wxEvtHandler,
38298 _swigc__p_wxFSFile,
38299 _swigc__p_wxFileConfig,
38300 _swigc__p_wxFileDataObject,
38301 _swigc__p_wxFileHistory,
38302 _swigc__p_wxFileSystem,
38303 _swigc__p_wxFileType,
38304 _swigc__p_wxFileTypeInfo,
38305 _swigc__p_wxFlexGridSizer,
38306 _swigc__p_wxFocusEvent,
38307 _swigc__p_wxFont,
38308 _swigc__p_wxFrame,
38309 _swigc__p_wxGBSizerItem,
38310 _swigc__p_wxGIFHandler,
38311 _swigc__p_wxGridBagSizer,
38312 _swigc__p_wxGridSizer,
38313 _swigc__p_wxICOHandler,
38314 _swigc__p_wxIcon,
38315 _swigc__p_wxIconizeEvent,
38316 _swigc__p_wxIdleEvent,
38317 _swigc__p_wxImage,
38318 _swigc__p_wxImageHandler,
38319 _swigc__p_wxIndividualLayoutConstraint,
38320 _swigc__p_wxInitDialogEvent,
38321 _swigc__p_wxJPEGHandler,
38322 _swigc__p_wxJoystick,
38323 _swigc__p_wxJoystickEvent,
38324 _swigc__p_wxKeyEvent,
38325 _swigc__p_wxKillError,
38326 _swigc__p_wxLayoutConstraints,
38327 _swigc__p_wxLog,
38328 _swigc__p_wxLogBuffer,
38329 _swigc__p_wxLogChain,
38330 _swigc__p_wxLogGui,
38331 _swigc__p_wxLogNull,
38332 _swigc__p_wxLogStderr,
38333 _swigc__p_wxLogTextCtrl,
38334 _swigc__p_wxLogWindow,
38335 _swigc__p_wxMaximizeEvent,
38336 _swigc__p_wxMenu,
38337 _swigc__p_wxMenuBar,
38338 _swigc__p_wxMenuEvent,
38339 _swigc__p_wxMenuItem,
38340 _swigc__p_wxMetafile,
38341 _swigc__p_wxMetafileDataObject,
38342 _swigc__p_wxMimeTypesManager,
38343 _swigc__p_wxMouseCaptureChangedEvent,
38344 _swigc__p_wxMouseEvent,
38345 _swigc__p_wxMouseState,
38346 _swigc__p_wxMoveEvent,
38347 _swigc__p_wxMutexGuiLocker,
38348 _swigc__p_wxNavigationKeyEvent,
38349 _swigc__p_wxNcPaintEvent,
38350 _swigc__p_wxNotifyEvent,
38351 _swigc__p_wxObject,
38352 _swigc__p_wxOutputStream,
38353 _swigc__p_wxPCXHandler,
38354 _swigc__p_wxPNGHandler,
38355 _swigc__p_wxPNMHandler,
38356 _swigc__p_wxPaintEvent,
38357 _swigc__p_wxPaletteChangedEvent,
38358 _swigc__p_wxPaperSize,
38359 _swigc__p_wxPoint,
38360 _swigc__p_wxPowerEvent,
38361 _swigc__p_wxProcessEvent,
38362 _swigc__p_wxPyApp,
38363 _swigc__p_wxPyArtProvider,
38364 _swigc__p_wxPyBitmapDataObject,
38365 _swigc__p_wxPyCommandEvent,
38366 _swigc__p_wxPyDataObjectSimple,
38367 _swigc__p_wxPyDropSource,
38368 _swigc__p_wxPyDropTarget,
38369 _swigc__p_wxPyEvent,
38370 _swigc__p_wxPyFileDropTarget,
38371 _swigc__p_wxPyImageHandler,
38372 _swigc__p_wxPyLog,
38373 _swigc__p_wxPyProcess,
38374 _swigc__p_wxPySizer,
38375 _swigc__p_wxPyTextDataObject,
38376 _swigc__p_wxPyTextDropTarget,
38377 _swigc__p_wxPyTimer,
38378 _swigc__p_wxPyTipProvider,
38379 _swigc__p_wxPyValidator,
38380 _swigc__p_wxQueryNewPaletteEvent,
38381 _swigc__p_wxRect,
38382 _swigc__p_wxScrollEvent,
38383 _swigc__p_wxScrollWinEvent,
38384 _swigc__p_wxSetCursorEvent,
38385 _swigc__p_wxShowEvent,
38386 _swigc__p_wxSingleInstanceChecker,
38387 _swigc__p_wxSize,
38388 _swigc__p_wxSizeEvent,
38389 _swigc__p_wxSizer,
38390 _swigc__p_wxSizerItem,
38391 _swigc__p_wxSound,
38392 _swigc__p_wxStandardPaths,
38393 _swigc__p_wxStaticBoxSizer,
38394 _swigc__p_wxStdDialogButtonSizer,
38395 _swigc__p_wxStopWatch,
38396 _swigc__p_wxString,
38397 _swigc__p_wxSysColourChangedEvent,
38398 _swigc__p_wxSystemOptions,
38399 _swigc__p_wxSystemSettings,
38400 _swigc__p_wxTIFFHandler,
38401 _swigc__p_wxTextCtrl,
38402 _swigc__p_wxTextDataObject,
38403 _swigc__p_wxTimeSpan,
38404 _swigc__p_wxTimer,
38405 _swigc__p_wxTimerEvent,
38406 _swigc__p_wxTimerRunner,
38407 _swigc__p_wxTipProvider,
38408 _swigc__p_wxToolTip,
38409 _swigc__p_wxURLDataObject,
38410 _swigc__p_wxUpdateUIEvent,
38411 _swigc__p_wxValidator,
38412 _swigc__p_wxVideoMode,
38413 _swigc__p_wxWindow,
38414 _swigc__p_wxWindowCreateEvent,
38415 _swigc__p_wxWindowDestroyEvent,
38416 _swigc__p_wxWindowDisabler,
38417 _swigc__p_wxXPMHandler,
38418 };
38419
38420
38421 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38422
38423 static swig_const_info swig_const_table[] = {
38424 {0, 0, 0, 0.0, 0, 0}};
38425
38426 #ifdef __cplusplus
38427 }
38428 #endif
38429 /* -----------------------------------------------------------------------------
38430 * Type initialization:
38431 * This problem is tough by the requirement that no dynamic
38432 * memory is used. Also, since swig_type_info structures store pointers to
38433 * swig_cast_info structures and swig_cast_info structures store pointers back
38434 * to swig_type_info structures, we need some lookup code at initialization.
38435 * The idea is that swig generates all the structures that are needed.
38436 * The runtime then collects these partially filled structures.
38437 * The SWIG_InitializeModule function takes these initial arrays out of
38438 * swig_module, and does all the lookup, filling in the swig_module.types
38439 * array with the correct data and linking the correct swig_cast_info
38440 * structures together.
38441 *
38442 * The generated swig_type_info structures are assigned staticly to an initial
38443 * array. We just loop though that array, and handle each type individually.
38444 * First we lookup if this type has been already loaded, and if so, use the
38445 * loaded structure instead of the generated one. Then we have to fill in the
38446 * cast linked list. The cast data is initially stored in something like a
38447 * two-dimensional array. Each row corresponds to a type (there are the same
38448 * number of rows as there are in the swig_type_initial array). Each entry in
38449 * a column is one of the swig_cast_info structures for that type.
38450 * The cast_initial array is actually an array of arrays, because each row has
38451 * a variable number of columns. So to actually build the cast linked list,
38452 * we find the array of casts associated with the type, and loop through it
38453 * adding the casts to the list. The one last trick we need to do is making
38454 * sure the type pointer in the swig_cast_info struct is correct.
38455 *
38456 * First off, we lookup the cast->type name to see if it is already loaded.
38457 * There are three cases to handle:
38458 * 1) If the cast->type has already been loaded AND the type we are adding
38459 * casting info to has not been loaded (it is in this module), THEN we
38460 * replace the cast->type pointer with the type pointer that has already
38461 * been loaded.
38462 * 2) If BOTH types (the one we are adding casting info to, and the
38463 * cast->type) are loaded, THEN the cast info has already been loaded by
38464 * the previous module so we just ignore it.
38465 * 3) Finally, if cast->type has not already been loaded, then we add that
38466 * swig_cast_info to the linked list (because the cast->type) pointer will
38467 * be correct.
38468 * ----------------------------------------------------------------------------- */
38469
38470 #ifdef __cplusplus
38471 extern "C" {
38472 #if 0
38473 } /* c-mode */
38474 #endif
38475 #endif
38476
38477 #if 0
38478 #define SWIGRUNTIME_DEBUG
38479 #endif
38480
38481 SWIGRUNTIME void
38482 SWIG_InitializeModule(void *clientdata) {
38483 size_t i;
38484 swig_module_info *module_head;
38485 static int init_run = 0;
38486
38487 clientdata = clientdata;
38488
38489 if (init_run) return;
38490 init_run = 1;
38491
38492 /* Initialize the swig_module */
38493 swig_module.type_initial = swig_type_initial;
38494 swig_module.cast_initial = swig_cast_initial;
38495
38496 /* Try and load any already created modules */
38497 module_head = SWIG_GetModule(clientdata);
38498 if (module_head) {
38499 swig_module.next = module_head->next;
38500 module_head->next = &swig_module;
38501 } else {
38502 /* This is the first module loaded */
38503 swig_module.next = &swig_module;
38504 SWIG_SetModule(clientdata, &swig_module);
38505 }
38506
38507 /* Now work on filling in swig_module.types */
38508 #ifdef SWIGRUNTIME_DEBUG
38509 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38510 #endif
38511 for (i = 0; i < swig_module.size; ++i) {
38512 swig_type_info *type = 0;
38513 swig_type_info *ret;
38514 swig_cast_info *cast;
38515
38516 #ifdef SWIGRUNTIME_DEBUG
38517 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38518 #endif
38519
38520 /* if there is another module already loaded */
38521 if (swig_module.next != &swig_module) {
38522 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38523 }
38524 if (type) {
38525 /* Overwrite clientdata field */
38526 #ifdef SWIGRUNTIME_DEBUG
38527 printf("SWIG_InitializeModule: found type %s\n", type->name);
38528 #endif
38529 if (swig_module.type_initial[i]->clientdata) {
38530 type->clientdata = swig_module.type_initial[i]->clientdata;
38531 #ifdef SWIGRUNTIME_DEBUG
38532 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38533 #endif
38534 }
38535 } else {
38536 type = swig_module.type_initial[i];
38537 }
38538
38539 /* Insert casting types */
38540 cast = swig_module.cast_initial[i];
38541 while (cast->type) {
38542 /* Don't need to add information already in the list */
38543 ret = 0;
38544 #ifdef SWIGRUNTIME_DEBUG
38545 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38546 #endif
38547 if (swig_module.next != &swig_module) {
38548 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38549 #ifdef SWIGRUNTIME_DEBUG
38550 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38551 #endif
38552 }
38553 if (ret) {
38554 if (type == swig_module.type_initial[i]) {
38555 #ifdef SWIGRUNTIME_DEBUG
38556 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38557 #endif
38558 cast->type = ret;
38559 ret = 0;
38560 } else {
38561 /* Check for casting already in the list */
38562 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38563 #ifdef SWIGRUNTIME_DEBUG
38564 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38565 #endif
38566 if (!ocast) ret = 0;
38567 }
38568 }
38569
38570 if (!ret) {
38571 #ifdef SWIGRUNTIME_DEBUG
38572 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38573 #endif
38574 if (type->cast) {
38575 type->cast->prev = cast;
38576 cast->next = type->cast;
38577 }
38578 type->cast = cast;
38579 }
38580 cast++;
38581 }
38582 /* Set entry in modules->types array equal to the type */
38583 swig_module.types[i] = type;
38584 }
38585 swig_module.types[i] = 0;
38586
38587 #ifdef SWIGRUNTIME_DEBUG
38588 printf("**** SWIG_InitializeModule: Cast List ******\n");
38589 for (i = 0; i < swig_module.size; ++i) {
38590 int j = 0;
38591 swig_cast_info *cast = swig_module.cast_initial[i];
38592 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38593 while (cast->type) {
38594 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38595 cast++;
38596 ++j;
38597 }
38598 printf("---- Total casts: %d\n",j);
38599 }
38600 printf("**** SWIG_InitializeModule: Cast List ******\n");
38601 #endif
38602 }
38603
38604 /* This function will propagate the clientdata field of type to
38605 * any new swig_type_info structures that have been added into the list
38606 * of equivalent types. It is like calling
38607 * SWIG_TypeClientData(type, clientdata) a second time.
38608 */
38609 SWIGRUNTIME void
38610 SWIG_PropagateClientData(void) {
38611 size_t i;
38612 swig_cast_info *equiv;
38613 static int init_run = 0;
38614
38615 if (init_run) return;
38616 init_run = 1;
38617
38618 for (i = 0; i < swig_module.size; i++) {
38619 if (swig_module.types[i]->clientdata) {
38620 equiv = swig_module.types[i]->cast;
38621 while (equiv) {
38622 if (!equiv->converter) {
38623 if (equiv->type && !equiv->type->clientdata)
38624 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38625 }
38626 equiv = equiv->next;
38627 }
38628 }
38629 }
38630 }
38631
38632 #ifdef __cplusplus
38633 #if 0
38634 {
38635 /* c-mode */
38636 #endif
38637 }
38638 #endif
38639
38640
38641
38642 #ifdef __cplusplus
38643 extern "C" {
38644 #endif
38645
38646 /* Python-specific SWIG API */
38647 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38648 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38649 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38650
38651 /* -----------------------------------------------------------------------------
38652 * global variable support code.
38653 * ----------------------------------------------------------------------------- */
38654
38655 typedef struct swig_globalvar {
38656 char *name; /* Name of global variable */
38657 PyObject *(*get_attr)(void); /* Return the current value */
38658 int (*set_attr)(PyObject *); /* Set the value */
38659 struct swig_globalvar *next;
38660 } swig_globalvar;
38661
38662 typedef struct swig_varlinkobject {
38663 PyObject_HEAD
38664 swig_globalvar *vars;
38665 } swig_varlinkobject;
38666
38667 SWIGINTERN PyObject *
38668 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38669 return PyString_FromString("<Swig global variables>");
38670 }
38671
38672 SWIGINTERN PyObject *
38673 swig_varlink_str(swig_varlinkobject *v) {
38674 PyObject *str = PyString_FromString("(");
38675 swig_globalvar *var;
38676 for (var = v->vars; var; var=var->next) {
38677 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38678 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38679 }
38680 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38681 return str;
38682 }
38683
38684 SWIGINTERN int
38685 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38686 PyObject *str = swig_varlink_str(v);
38687 fprintf(fp,"Swig global variables ");
38688 fprintf(fp,"%s\n", PyString_AsString(str));
38689 Py_DECREF(str);
38690 return 0;
38691 }
38692
38693 SWIGINTERN void
38694 swig_varlink_dealloc(swig_varlinkobject *v) {
38695 swig_globalvar *var = v->vars;
38696 while (var) {
38697 swig_globalvar *n = var->next;
38698 free(var->name);
38699 free(var);
38700 var = n;
38701 }
38702 }
38703
38704 SWIGINTERN PyObject *
38705 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38706 PyObject *res = NULL;
38707 swig_globalvar *var = v->vars;
38708 while (var) {
38709 if (strcmp(var->name,n) == 0) {
38710 res = (*var->get_attr)();
38711 break;
38712 }
38713 var = var->next;
38714 }
38715 if (res == NULL && !PyErr_Occurred()) {
38716 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38717 }
38718 return res;
38719 }
38720
38721 SWIGINTERN int
38722 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38723 int res = 1;
38724 swig_globalvar *var = v->vars;
38725 while (var) {
38726 if (strcmp(var->name,n) == 0) {
38727 res = (*var->set_attr)(p);
38728 break;
38729 }
38730 var = var->next;
38731 }
38732 if (res == 1 && !PyErr_Occurred()) {
38733 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38734 }
38735 return res;
38736 }
38737
38738 SWIGINTERN PyTypeObject*
38739 swig_varlink_type(void) {
38740 static char varlink__doc__[] = "Swig var link object";
38741 static PyTypeObject varlink_type;
38742 static int type_init = 0;
38743 if (!type_init) {
38744 const PyTypeObject tmp
38745 = {
38746 PyObject_HEAD_INIT(NULL)
38747 0, /* Number of items in variable part (ob_size) */
38748 (char *)"swigvarlink", /* Type name (tp_name) */
38749 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38750 0, /* Itemsize (tp_itemsize) */
38751 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38752 (printfunc) swig_varlink_print, /* Print (tp_print) */
38753 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38754 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38755 0, /* tp_compare */
38756 (reprfunc) swig_varlink_repr, /* tp_repr */
38757 0, /* tp_as_number */
38758 0, /* tp_as_sequence */
38759 0, /* tp_as_mapping */
38760 0, /* tp_hash */
38761 0, /* tp_call */
38762 (reprfunc)swig_varlink_str, /* tp_str */
38763 0, /* tp_getattro */
38764 0, /* tp_setattro */
38765 0, /* tp_as_buffer */
38766 0, /* tp_flags */
38767 varlink__doc__, /* tp_doc */
38768 0, /* tp_traverse */
38769 0, /* tp_clear */
38770 0, /* tp_richcompare */
38771 0, /* tp_weaklistoffset */
38772 #if PY_VERSION_HEX >= 0x02020000
38773 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38774 #endif
38775 #if PY_VERSION_HEX >= 0x02030000
38776 0, /* tp_del */
38777 #endif
38778 #ifdef COUNT_ALLOCS
38779 0,0,0,0 /* tp_alloc -> tp_next */
38780 #endif
38781 };
38782 varlink_type = tmp;
38783 varlink_type.ob_type = &PyType_Type;
38784 type_init = 1;
38785 }
38786 return &varlink_type;
38787 }
38788
38789 /* Create a variable linking object for use later */
38790 SWIGINTERN PyObject *
38791 SWIG_Python_newvarlink(void) {
38792 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38793 if (result) {
38794 result->vars = 0;
38795 }
38796 return ((PyObject*) result);
38797 }
38798
38799 SWIGINTERN void
38800 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38801 swig_varlinkobject *v = (swig_varlinkobject *) p;
38802 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38803 if (gv) {
38804 size_t size = strlen(name)+1;
38805 gv->name = (char *)malloc(size);
38806 if (gv->name) {
38807 strncpy(gv->name,name,size);
38808 gv->get_attr = get_attr;
38809 gv->set_attr = set_attr;
38810 gv->next = v->vars;
38811 }
38812 }
38813 v->vars = gv;
38814 }
38815
38816 SWIGINTERN PyObject *
38817 SWIG_globals() {
38818 static PyObject *_SWIG_globals = 0;
38819 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38820 return _SWIG_globals;
38821 }
38822
38823 /* -----------------------------------------------------------------------------
38824 * constants/methods manipulation
38825 * ----------------------------------------------------------------------------- */
38826
38827 /* Install Constants */
38828 SWIGINTERN void
38829 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38830 PyObject *obj = 0;
38831 size_t i;
38832 for (i = 0; constants[i].type; ++i) {
38833 switch(constants[i].type) {
38834 case SWIG_PY_POINTER:
38835 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38836 break;
38837 case SWIG_PY_BINARY:
38838 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38839 break;
38840 default:
38841 obj = 0;
38842 break;
38843 }
38844 if (obj) {
38845 PyDict_SetItemString(d, constants[i].name, obj);
38846 Py_DECREF(obj);
38847 }
38848 }
38849 }
38850
38851 /* -----------------------------------------------------------------------------*/
38852 /* Fix SwigMethods to carry the callback ptrs when needed */
38853 /* -----------------------------------------------------------------------------*/
38854
38855 SWIGINTERN void
38856 SWIG_Python_FixMethods(PyMethodDef *methods,
38857 swig_const_info *const_table,
38858 swig_type_info **types,
38859 swig_type_info **types_initial) {
38860 size_t i;
38861 for (i = 0; methods[i].ml_name; ++i) {
38862 const char *c = methods[i].ml_doc;
38863 if (c && (c = strstr(c, "swig_ptr: "))) {
38864 int j;
38865 swig_const_info *ci = 0;
38866 const char *name = c + 10;
38867 for (j = 0; const_table[j].type; ++j) {
38868 if (strncmp(const_table[j].name, name,
38869 strlen(const_table[j].name)) == 0) {
38870 ci = &(const_table[j]);
38871 break;
38872 }
38873 }
38874 if (ci) {
38875 size_t shift = (ci->ptype) - types;
38876 swig_type_info *ty = types_initial[shift];
38877 size_t ldoc = (c - methods[i].ml_doc);
38878 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38879 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38880 if (ndoc) {
38881 char *buff = ndoc;
38882 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38883 if (ptr) {
38884 strncpy(buff, methods[i].ml_doc, ldoc);
38885 buff += ldoc;
38886 strncpy(buff, "swig_ptr: ", 10);
38887 buff += 10;
38888 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38889 methods[i].ml_doc = ndoc;
38890 }
38891 }
38892 }
38893 }
38894 }
38895 }
38896
38897 #ifdef __cplusplus
38898 }
38899 #endif
38900
38901 /* -----------------------------------------------------------------------------*
38902 * Partial Init method
38903 * -----------------------------------------------------------------------------*/
38904
38905 #ifdef __cplusplus
38906 extern "C"
38907 #endif
38908 SWIGEXPORT void SWIG_init(void) {
38909 PyObject *m, *d;
38910
38911 /* Fix SwigMethods to carry the callback ptrs when needed */
38912 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38913
38914 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38915 d = PyModule_GetDict(m);
38916
38917 SWIG_InitializeModule(0);
38918 SWIG_InstallConstants(d,swig_const_table);
38919
38920
38921 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38922 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38923 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38924 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38925 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38926 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38927 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38928 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38929 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38930 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38931 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38932 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38933 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38934 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38935 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38936 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38937 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38938 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38939 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38940 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38941 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38942 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38943 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38944 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38945 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38946 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38947 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38948 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38949 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38950 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38951 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38952 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38953 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38954 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38955 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38956 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38957 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38958 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38959 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38960 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38961 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38962 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38963 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38964 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38965 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38966 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38967 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38968 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38969 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38970 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38971 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38972 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38973 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38974 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38975 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38976 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38977 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38978 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38979 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38980 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38981 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38982 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38983 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38984 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38985 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38986 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38987 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38988 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38989 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38990 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38991 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38992 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38993 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38994 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38995 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38996 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38997 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38998 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38999 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
39000 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
39001 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
39002 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
39003 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
39004 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
39005 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
39006 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
39007 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
39008 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
39009 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
39010 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
39011 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
39012 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
39013 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
39014 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
39015 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
39016 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
39017 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
39018 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
39019 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
39020 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
39021 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
39022 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
39023 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
39024 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
39025 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
39026 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
39027 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
39028 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
39029 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
39030 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
39031 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
39032 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
39033 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
39034 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
39035 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
39036 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
39037 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
39038 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
39039 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
39040 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
39041 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
39042 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
39043 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
39044 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
39045 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
39046 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
39047 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
39048 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
39049 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
39050 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
39051 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
39052 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
39053 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
39054 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
39055 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
39056 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
39057 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
39058
39059 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
39060
39061 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
39062 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
39063 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
39064 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
39065 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
39066 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
39067 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
39068 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
39069 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
39070 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
39071 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
39072 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
39073 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
39074 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
39075 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
39076 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
39077 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
39078 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
39079 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
39080 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
39081 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
39082 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
39083 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
39084 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
39085 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
39086 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
39087 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
39088 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
39089 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
39090 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
39091 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
39092 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
39093 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
39094 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
39095 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
39096 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
39097 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
39098 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
39099 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
39100 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
39101 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
39102 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
39103 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
39104 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
39105 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
39106 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
39107 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
39108 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
39109 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
39110 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
39111 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
39112 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
39113 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
39114
39115 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
39116
39117 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
39118 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
39119 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
39120 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
39121 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
39122 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
39123 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
39124 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
39125 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
39126 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
39127 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
39128 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
39129 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
39130 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
39131 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
39132 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
39133 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
39134 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
39135 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
39136 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
39137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
39138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
39139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
39140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
39141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
39142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
39143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
39144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
39145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
39146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
39147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
39148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
39149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
39150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
39151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39193
39194 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39195
39196 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39197 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39198 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39199 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39200 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39201 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39202 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39203 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39204 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39205 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39206 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39207 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39208 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39209 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39210 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39211 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39212 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39213 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39214 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39215 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39216 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39217 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39218 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39219 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39220 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39221 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39222 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39223 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39224 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39225 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39226 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39227 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39228 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39229 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39230 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39231 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39232 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39233 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39234 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39235 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39236 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39237 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39238 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39239 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39240 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39241 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39242 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39243 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39244 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39245 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39246 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39247 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39248 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39249 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39250 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39251 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39252 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39253 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39254 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39255 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39256 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39257 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39258 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39259 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39260 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39261 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39262 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39263 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39264 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39265 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39266 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39267 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39268 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39269 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39270 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39271 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39272 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39273 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39274 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39275 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39276 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39277 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39278 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39279 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39280 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39281 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39282 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39283 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39284 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39285 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39286 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39287 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39288 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39289 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39290 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39291 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39292 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39293 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39294 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39295 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39296 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39297 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39298 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39299 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39300 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39301 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39302 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39303 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39304 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39305 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39306 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39307 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39308 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39309 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39310 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39311 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39312 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39313 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39314 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39315 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39316 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39317 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39318 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39319 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39320 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39321 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39322 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39323 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39324 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39325 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39326 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39327 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39328 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39329 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39330 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39331 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39332 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39333 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39334 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39335 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39336 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39337 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39338 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39339 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39340 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39341 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39342 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39343 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39344 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39345 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39346 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39347 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39348 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39349 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39350 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39351 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39352 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39353 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39354 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39355 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39356 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39357 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39358 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39359 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39360 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39361 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39362 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39363 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39364 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39365 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39366 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39367 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39368 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39369 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39370 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39371 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39372 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39373 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39374 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39375 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39376 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39377 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39378 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39379 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39380 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39381 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39382 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39383 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39384 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39385 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39386 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39387 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39388 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39389 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39390 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39391 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39392 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39393 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39394 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39395 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39396
39397 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39398 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39399 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39400 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39401
39402 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39403 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39404 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39405 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39406 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39407 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39408 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39409 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39410 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39411 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39412 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39413 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39414 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39415 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39416 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39417 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39418 }
39419
wxWidgets (Impactor)