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


35c6aeea0c5b6efc4479c2912ae92c89a2fab5de
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMemorySize swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPoint swig_types[113]
2580 #define SWIGTYPE_p_wxPowerEvent swig_types[114]
2581 #define SWIGTYPE_p_wxProcessEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPyApp swig_types[116]
2583 #define SWIGTYPE_p_wxPyArtProvider swig_types[117]
2584 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[118]
2585 #define SWIGTYPE_p_wxPyCommandEvent swig_types[119]
2586 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropSource swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
2589 #define SWIGTYPE_p_wxPyEvent swig_types[123]
2590 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyImageHandler swig_types[125]
2592 #define SWIGTYPE_p_wxPyLog swig_types[126]
2593 #define SWIGTYPE_p_wxPyProcess swig_types[127]
2594 #define SWIGTYPE_p_wxPySizer swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDataObject swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[130]
2597 #define SWIGTYPE_p_wxPyTimer swig_types[131]
2598 #define SWIGTYPE_p_wxPyTipProvider swig_types[132]
2599 #define SWIGTYPE_p_wxPyValidator swig_types[133]
2600 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[134]
2601 #define SWIGTYPE_p_wxRect swig_types[135]
2602 #define SWIGTYPE_p_wxScrollEvent swig_types[136]
2603 #define SWIGTYPE_p_wxScrollWinEvent swig_types[137]
2604 #define SWIGTYPE_p_wxSetCursorEvent swig_types[138]
2605 #define SWIGTYPE_p_wxShowEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[140]
2607 #define SWIGTYPE_p_wxSize swig_types[141]
2608 #define SWIGTYPE_p_wxSizeEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSizer swig_types[143]
2610 #define SWIGTYPE_p_wxSizerItem swig_types[144]
2611 #define SWIGTYPE_p_wxSound swig_types[145]
2612 #define SWIGTYPE_p_wxStandardPaths swig_types[146]
2613 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStopWatch swig_types[149]
2616 #define SWIGTYPE_p_wxString swig_types[150]
2617 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[151]
2618 #define SWIGTYPE_p_wxSystemOptions swig_types[152]
2619 #define SWIGTYPE_p_wxSystemSettings swig_types[153]
2620 #define SWIGTYPE_p_wxTIFFHandler swig_types[154]
2621 #define SWIGTYPE_p_wxTextCtrl swig_types[155]
2622 #define SWIGTYPE_p_wxTextDataObject swig_types[156]
2623 #define SWIGTYPE_p_wxTimeSpan swig_types[157]
2624 #define SWIGTYPE_p_wxTimer swig_types[158]
2625 #define SWIGTYPE_p_wxTimerEvent swig_types[159]
2626 #define SWIGTYPE_p_wxTimerRunner swig_types[160]
2627 #define SWIGTYPE_p_wxTipProvider swig_types[161]
2628 #define SWIGTYPE_p_wxToolTip swig_types[162]
2629 #define SWIGTYPE_p_wxURLDataObject swig_types[163]
2630 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[164]
2631 #define SWIGTYPE_p_wxValidator swig_types[165]
2632 #define SWIGTYPE_p_wxVideoMode swig_types[166]
2633 #define SWIGTYPE_p_wxWindow swig_types[167]
2634 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDisabler swig_types[170]
2637 #define SWIGTYPE_p_wxXPMHandler swig_types[171]
2638 static swig_type_info *swig_types[173];
2639 static swig_module_info swig_module = {swig_types, 172, 0, 0, 0, 0};
2640 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2641 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2642
2643 /* -------- TYPES TABLE (END) -------- */
2644
2645 #if (PY_VERSION_HEX <= 0x02000000)
2646 # if !defined(SWIG_PYTHON_CLASSIC)
2647 # error "This python version requires to use swig with the '-classic' option"
2648 # endif
2649 #endif
2650 #if (PY_VERSION_HEX <= 0x02020000)
2651 # error "This python version requires to use swig with the '-nomodern' option"
2652 #endif
2653 #if (PY_VERSION_HEX <= 0x02020000)
2654 # error "This python version requires to use swig with the '-nomodernargs' option"
2655 #endif
2656 #ifndef METH_O
2657 # error "This python version requires to use swig with the '-nofastunpack' option"
2658 #endif
2659
2660 /*-----------------------------------------------
2661 @(target):= _misc_.so
2662 ------------------------------------------------*/
2663 #define SWIG_init init_misc_
2664
2665 #define SWIG_name "_misc_"
2666
2667 #define SWIGVERSION 0x010329
2668
2669
2670 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2671 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2672
2673
2674 #include <stdexcept>
2675
2676
2677 namespace swig {
2678 class PyObject_ptr {
2679 protected:
2680 PyObject *_obj;
2681
2682 public:
2683 PyObject_ptr() :_obj(0)
2684 {
2685 }
2686
2687 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2688 {
2689 Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2693 {
2694 if (initial_ref) Py_XINCREF(_obj);
2695 }
2696
2697 PyObject_ptr & operator=(const PyObject_ptr& item)
2698 {
2699 Py_XINCREF(item._obj);
2700 Py_XDECREF(_obj);
2701 _obj = item._obj;
2702 return *this;
2703 }
2704
2705 ~PyObject_ptr()
2706 {
2707 Py_XDECREF(_obj);
2708 }
2709
2710 operator PyObject *() const
2711 {
2712 return _obj;
2713 }
2714
2715 PyObject *operator->() const
2716 {
2717 return _obj;
2718 }
2719 };
2720 }
2721
2722
2723 namespace swig {
2724 struct PyObject_var : PyObject_ptr {
2725 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2726
2727 PyObject_var & operator = (PyObject* obj)
2728 {
2729 Py_XDECREF(_obj);
2730 _obj = obj;
2731 return *this;
2732 }
2733 };
2734 }
2735
2736
2737 #include "wx/wxPython/wxPython.h"
2738 #include "wx/wxPython/pyclasses.h"
2739 #include "wx/wxPython/pyistream.h"
2740
2741 static const wxString wxPyEmptyString(wxEmptyString);
2742
2743
2744
2745 #define SWIG_From_long PyInt_FromLong
2746
2747
2748 SWIGINTERNINLINE PyObject *
2749 SWIG_From_int (int value)
2750 {
2751 return SWIG_From_long (value);
2752 }
2753
2754
2755 #include <limits.h>
2756 #ifndef LLONG_MIN
2757 # define LLONG_MIN LONG_LONG_MIN
2758 #endif
2759 #ifndef LLONG_MAX
2760 # define LLONG_MAX LONG_LONG_MAX
2761 #endif
2762 #ifndef ULLONG_MAX
2763 # define ULLONG_MAX ULONG_LONG_MAX
2764 #endif
2765
2766
2767 SWIGINTERN int
2768 SWIG_AsVal_long (PyObject* obj, long* val)
2769 {
2770 if (PyNumber_Check(obj)) {
2771 if (val) *val = PyInt_AsLong(obj);
2772 return SWIG_OK;
2773 }
2774 return SWIG_TypeError;
2775 }
2776
2777
2778 SWIGINTERN int
2779 SWIG_AsVal_int (PyObject * obj, int *val)
2780 {
2781 long v;
2782 int res = SWIG_AsVal_long (obj, &v);
2783 if (SWIG_IsOK(res)) {
2784 if ((v < INT_MIN || v > INT_MAX)) {
2785 return SWIG_OverflowError;
2786 } else {
2787 if (val) *val = static_cast< int >(v);
2788 }
2789 }
2790 return res;
2791 }
2792
2793 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2794
2795 #include <wx/stockitem.h>
2796
2797 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2798 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2799 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2800
2801 SWIGINTERN int
2802 SWIG_AsVal_bool (PyObject *obj, bool *val)
2803 {
2804 if (obj == Py_True) {
2805 if (val) *val = true;
2806 return SWIG_OK;
2807 } else if (obj == Py_False) {
2808 if (val) *val = false;
2809 return SWIG_OK;
2810 } else {
2811 long v = 0;
2812 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2813 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2814 return res;
2815 }
2816 }
2817
2818
2819 SWIGINTERN int
2820 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2821 {
2822 long v = 0;
2823 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2824 return SWIG_TypeError;
2825 }
2826 else if (val)
2827 *val = (unsigned long)v;
2828 return SWIG_OK;
2829 }
2830
2831
2832 SWIGINTERNINLINE PyObject*
2833 SWIG_From_unsigned_SS_long (unsigned long value)
2834 {
2835 return (value > LONG_MAX) ?
2836 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2837 }
2838
2839
2840 void* wxGetXDisplay()
2841 {
2842 #ifdef __WXGTK__
2843 return wxGetDisplay();
2844 #else
2845 return NULL;
2846 #endif
2847 }
2848
2849
2850 wxWindow* FindWindowAtPointer() {
2851 wxPoint unused;
2852 return wxFindWindowAtPointer(unused);
2853 }
2854
2855
2856 bool wxThread_IsMain() {
2857 #ifdef WXP_WITH_THREAD
2858 return wxThread::IsMain();
2859 #else
2860 return true;
2861 #endif
2862 }
2863
2864 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2865 delete self;
2866 }
2867
2868 #include <wx/snglinst.h>
2869
2870
2871 #ifdef __WXMSW__
2872 #include <wx/msw/private.h>
2873 #include <wx/dynload.h>
2874 #endif
2875
2876
2877
2878 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2879 #if 0
2880 , int method
2881 #endif
2882 )
2883 {
2884 #ifdef __WXMSW__
2885 #if 0
2886 switch (method)
2887 {
2888 case 1:
2889 // This one only partially works. Appears to be an undocumented
2890 // "standard" convention that not all widgets adhear to. For
2891 // example, for some widgets backgrounds or non-client areas may
2892 // not be painted.
2893 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2894 break;
2895
2896 case 2:
2897 #endif
2898 // This one works much better, nearly all widgets and their
2899 // children are captured correctly[**]. Prior to the big
2900 // background erase changes that Vadim did in 2004-2005 this
2901 // method failed badly on XP with Themes activated, most native
2902 // widgets draw only partially, if at all. Without themes it
2903 // worked just like on Win2k. After those changes this method
2904 // works very well.
2905 //
2906 // ** For example the radio buttons in a wxRadioBox are not its
2907 // children by default, but you can capture it via the panel
2908 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2909 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2910 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2911 PRF_ERASEBKGND | PRF_OWNED );
2912 return true;
2913 #if 0
2914 break;
2915
2916 case 3:
2917 // This one is only defined in the latest SDK and is only
2918 // available on XP. MSDN says it is similar to sending WM_PRINT
2919 // so I expect that it will work similar to the above. Since it
2920 // is avaialble only on XP, it can't be compiled like this and
2921 // will have to be loaded dynamically.
2922 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2923
2924 // fall through
2925
2926 case 4:
2927 // Use PrintWindow if available, or fallback to WM_PRINT
2928 // otherwise. Unfortunately using PrintWindow is even worse than
2929 // WM_PRINT. For most native widgets nothing is drawn to the dc
2930 // at all, with or without Themes.
2931 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2932 static bool s_triedToLoad = false;
2933 static PrintWindow_t pfnPrintWindow = NULL;
2934 if ( !s_triedToLoad )
2935 {
2936
2937 s_triedToLoad = true;
2938 wxDynamicLibrary dllUser32(_T("user32.dll"));
2939 if ( dllUser32.IsLoaded() )
2940 {
2941 wxLogNull nolog; // Don't report errors here
2942 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2943 }
2944 }
2945 if (pfnPrintWindow)
2946 {
2947 //printf("Using PrintWindow\n");
2948 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2949 }
2950 else
2951 {
2952 //printf("Using WM_PRINT\n");
2953 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2954 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2955 PRF_ERASEBKGND | PRF_OWNED );
2956 }
2957 }
2958 #endif // 0
2959 #else
2960 return false;
2961 #endif // __WXMSW__
2962 }
2963
2964
2965
2966 #include <wx/tipdlg.h>
2967
2968
2969 SWIGINTERNINLINE PyObject *
2970 SWIG_From_size_t (size_t value)
2971 {
2972 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2973 }
2974
2975
2976 class wxPyTipProvider : public wxTipProvider {
2977 public:
2978 wxPyTipProvider(size_t currentTip)
2979 : wxTipProvider(currentTip) {}
2980
2981 DEC_PYCALLBACK_STRING__pure(GetTip);
2982 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2983 PYPRIVATE;
2984 };
2985
2986 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2987 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2988
2989
2990 SWIGINTERNINLINE int
2991 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2992 {
2993 unsigned long v;
2994 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2995 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2996 return res;
2997 }
2998
2999
3000 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3001
3002 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3003
3004 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3005 : wxTimer(owner, id)
3006 {
3007 if (owner == NULL)
3008 SetOwner(this);
3009 }
3010
3011
3012 SWIGINTERN swig_type_info*
3013 SWIG_pchar_descriptor()
3014 {
3015 static int init = 0;
3016 static swig_type_info* info = 0;
3017 if (!init) {
3018 info = SWIG_TypeQuery("_p_char");
3019 init = 1;
3020 }
3021 return info;
3022 }
3023
3024
3025 SWIGINTERNINLINE PyObject *
3026 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3027 {
3028 if (carray) {
3029 if (size > INT_MAX) {
3030 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3031 return pchar_descriptor ?
3032 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3033 } else {
3034 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3035 }
3036 } else {
3037 return SWIG_Py_Void();
3038 }
3039 }
3040
3041
3042 SWIGINTERNINLINE PyObject *
3043 SWIG_FromCharPtr(const char *cptr)
3044 {
3045 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3046 }
3047
3048
3049 SWIGINTERN int
3050 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3051 {
3052 unsigned long v;
3053 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3054 if (SWIG_IsOK(res)) {
3055 if ((v > UINT_MAX)) {
3056 return SWIG_OverflowError;
3057 } else {
3058 if (val) *val = static_cast< unsigned int >(v);
3059 }
3060 }
3061 return res;
3062 }
3063
3064 SWIGINTERN wxString wxLog_TimeStamp(){
3065 wxString msg;
3066 wxLog::TimeStamp(&msg);
3067 return msg;
3068 }
3069 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3070 // Make some wrappers that double any % signs so they are 'escaped'
3071 void wxPyLogFatalError(const wxString& msg)
3072 {
3073 wxString m(msg);
3074 m.Replace(wxT("%"), wxT("%%"));
3075 wxLogFatalError(m);
3076 }
3077
3078 void wxPyLogError(const wxString& msg)
3079 {
3080 wxString m(msg);
3081 m.Replace(wxT("%"), wxT("%%"));
3082 wxLogError(m);
3083 }
3084
3085 void wxPyLogWarning(const wxString& msg)
3086 {
3087 wxString m(msg);
3088 m.Replace(wxT("%"), wxT("%%"));
3089 wxLogWarning(m);
3090 }
3091
3092 void wxPyLogMessage(const wxString& msg)
3093 {
3094 wxString m(msg);
3095 m.Replace(wxT("%"), wxT("%%"));
3096 wxLogMessage(m);
3097 }
3098
3099 void wxPyLogInfo(const wxString& msg)
3100 {
3101 wxString m(msg);
3102 m.Replace(wxT("%"), wxT("%%"));
3103 wxLogInfo(m);
3104 }
3105
3106 void wxPyLogDebug(const wxString& msg)
3107 {
3108 wxString m(msg);
3109 m.Replace(wxT("%"), wxT("%%"));
3110 wxLogDebug(m);
3111 }
3112
3113 void wxPyLogVerbose(const wxString& msg)
3114 {
3115 wxString m(msg);
3116 m.Replace(wxT("%"), wxT("%%"));
3117 wxLogVerbose(m);
3118 }
3119
3120 void wxPyLogStatus(const wxString& msg)
3121 {
3122 wxString m(msg);
3123 m.Replace(wxT("%"), wxT("%%"));
3124 wxLogStatus(m);
3125 }
3126
3127 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3128 {
3129 wxString m(msg);
3130 m.Replace(wxT("%"), wxT("%%"));
3131 wxLogStatus(pFrame, m);
3132 }
3133
3134 void wxPyLogSysError(const wxString& msg)
3135 {
3136 wxString m(msg);
3137 m.Replace(wxT("%"), wxT("%%"));
3138 wxLogSysError(m);
3139 }
3140
3141 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3142 {
3143 wxString m(msg);
3144 m.Replace(wxT("%"), wxT("%%"));
3145 wxLogGeneric(level, m);
3146 }
3147
3148 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3149 {
3150 wxString m(msg);
3151 m.Replace(wxT("%"), wxT("%%"));
3152 wxLogTrace(mask, m);
3153 }
3154
3155 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3156 {
3157 wxString m(msg);
3158 m.Replace(wxT("%"), wxT("%%"));
3159 wxLogTrace(mask, m);
3160 }
3161
3162
3163
3164 // A wxLog class that can be derived from in wxPython
3165 class wxPyLog : public wxLog {
3166 public:
3167 wxPyLog() : wxLog() {}
3168
3169 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3170 bool found;
3171 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3172 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3173 PyObject* s = wx2PyString(szString);
3174 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3175 Py_DECREF(s);
3176 }
3177 wxPyEndBlockThreads(blocked);
3178 if (! found)
3179 wxLog::DoLog(level, szString, t);
3180 }
3181
3182 virtual void DoLogString(const wxChar *szString, time_t t) {
3183 bool found;
3184 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3185 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3186 PyObject* s = wx2PyString(szString);
3187 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3188 Py_DECREF(s);
3189 }
3190 wxPyEndBlockThreads(blocked);
3191 if (! found)
3192 wxLog::DoLogString(szString, t);
3193 }
3194
3195 DEC_PYCALLBACK_VOID_(Flush);
3196 PYPRIVATE;
3197 };
3198 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3199
3200
3201
3202
3203 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3204
3205
3206 #include <wx/joystick.h>
3207
3208
3209 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3210 // A C++ stub class for wxJoystick for platforms that don't have it.
3211 class wxJoystick : public wxObject {
3212 public:
3213 wxJoystick(int joystick = wxJOYSTICK1) {
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 PyErr_SetString(PyExc_NotImplementedError,
3216 "wxJoystick is not available on this platform.");
3217 wxPyEndBlockThreads(blocked);
3218 }
3219 wxPoint GetPosition() { return wxPoint(-1,-1); }
3220 int GetZPosition() { return -1; }
3221 int GetButtonState() { return -1; }
3222 int GetPOVPosition() { return -1; }
3223 int GetPOVCTSPosition() { return -1; }
3224 int GetRudderPosition() { return -1; }
3225 int GetUPosition() { return -1; }
3226 int GetVPosition() { return -1; }
3227 int GetMovementThreshold() { return -1; }
3228 void SetMovementThreshold(int threshold) {}
3229
3230 bool IsOk(void) { return false; }
3231 int GetNumberJoysticks() { return -1; }
3232 int GetManufacturerId() { return -1; }
3233 int GetProductId() { return -1; }
3234 wxString GetProductName() { return wxEmptyString; }
3235 int GetXMin() { return -1; }
3236 int GetYMin() { return -1; }
3237 int GetZMin() { return -1; }
3238 int GetXMax() { return -1; }
3239 int GetYMax() { return -1; }
3240 int GetZMax() { return -1; }
3241 int GetNumberButtons() { return -1; }
3242 int GetNumberAxes() { return -1; }
3243 int GetMaxButtons() { return -1; }
3244 int GetMaxAxes() { return -1; }
3245 int GetPollingMin() { return -1; }
3246 int GetPollingMax() { return -1; }
3247 int GetRudderMin() { return -1; }
3248 int GetRudderMax() { return -1; }
3249 int GetUMin() { return -1; }
3250 int GetUMax() { return -1; }
3251 int GetVMin() { return -1; }
3252 int GetVMax() { return -1; }
3253
3254 bool HasRudder() { return false; }
3255 bool HasZ() { return false; }
3256 bool HasU() { return false; }
3257 bool HasV() { return false; }
3258 bool HasPOV() { return false; }
3259 bool HasPOV4Dir() { return false; }
3260 bool HasPOVCTS() { return false; }
3261
3262 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3263 bool ReleaseCapture() { return false; }
3264 };
3265 #endif
3266
3267
3268 #include <wx/sound.h>
3269
3270
3271 #if !wxUSE_SOUND
3272 // A C++ stub class for wxWave for platforms that don't have it.
3273 class wxSound : public wxObject
3274 {
3275 public:
3276 wxSound() {
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 PyErr_SetString(PyExc_NotImplementedError,
3279 "wxSound is not available on this platform.");
3280 wxPyEndBlockThreads(blocked);
3281 }
3282 wxSound(const wxString&/*, bool*/) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288 wxSound(int, const wxByte*) {
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 PyErr_SetString(PyExc_NotImplementedError,
3291 "wxSound is not available on this platform.");
3292 wxPyEndBlockThreads(blocked);
3293 }
3294
3295 ~wxSound() {};
3296
3297 bool Create(const wxString&/*, bool*/) { return false; }
3298 bool Create(int, const wxByte*) { return false; };
3299 bool IsOk() { return false; };
3300 bool Play(unsigned) const { return false; }
3301 static bool Play(const wxString&, unsigned) { return false; }
3302 static void Stop() {}
3303 };
3304
3305 #endif
3306
3307 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3308 if (fileName.Length() == 0)
3309 return new wxSound;
3310 else
3311 return new wxSound(fileName);
3312 }
3313 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3314 unsigned char* buffer; int size;
3315 wxSound *sound = NULL;
3316
3317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3318 if (!PyArg_Parse(data, "t#", &buffer, &size))
3319 goto done;
3320 sound = new wxSound(size, buffer);
3321 done:
3322 wxPyEndBlockThreads(blocked);
3323 return sound;
3324 }
3325 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3326 #ifndef __WXMAC__
3327 unsigned char* buffer;
3328 int size;
3329 bool rv = false;
3330
3331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3332 if (!PyArg_Parse(data, "t#", &buffer, &size))
3333 goto done;
3334 rv = self->Create(size, buffer);
3335 done:
3336 wxPyEndBlockThreads(blocked);
3337 return rv;
3338 #else
3339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3340 PyErr_SetString(PyExc_NotImplementedError,
3341 "Create from data is not available on this platform.");
3342 wxPyEndBlockThreads(blocked);
3343 return false;
3344 #endif
3345 }
3346
3347 #include <wx/mimetype.h>
3348
3349 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3350 wxString str;
3351 if (self->GetMimeType(&str))
3352 return wx2PyString(str);
3353 else
3354 RETURN_NONE();
3355 }
3356 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3357 wxArrayString arr;
3358 if (self->GetMimeTypes(arr))
3359 return wxArrayString2PyList_helper(arr);
3360 else
3361 RETURN_NONE();
3362 }
3363 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3364 wxArrayString arr;
3365 if (self->GetExtensions(arr))
3366 return wxArrayString2PyList_helper(arr);
3367 else
3368 RETURN_NONE();
3369 }
3370 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3371 wxIconLocation loc;
3372 if (self->GetIcon(&loc))
3373 return new wxIcon(loc);
3374 else
3375 return NULL;
3376 }
3377 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3378 wxIconLocation loc;
3379 if (self->GetIcon(&loc)) {
3380 wxString iconFile = loc.GetFileName();
3381 int iconIndex = -1;
3382
3383 iconIndex = loc.GetIndex();
3384
3385 // Make a tuple and put the values in it
3386 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3387 PyObject* tuple = PyTuple_New(3);
3388 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3389 wxT("wxIcon"), true));
3390 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3391 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3392 wxPyEndBlockThreads(blocked);
3393 return tuple;
3394 }
3395 else
3396 RETURN_NONE();
3397 }
3398 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3399 wxString str;
3400 if (self->GetDescription(&str))
3401 return wx2PyString(str);
3402 else
3403 RETURN_NONE();
3404 }
3405 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3406 wxString str;
3407 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3408 return wx2PyString(str);
3409 else
3410 RETURN_NONE();
3411 }
3412 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3413 wxString str;
3414 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3415 return wx2PyString(str);
3416 else
3417 RETURN_NONE();
3418 }
3419 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3420 wxArrayString verbs;
3421 wxArrayString commands;
3422 if (self->GetAllCommands(&verbs, &commands,
3423 wxFileType::MessageParameters(filename, mimetype))) {
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 PyObject* tuple = PyTuple_New(2);
3426 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3427 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3428 wxPyEndBlockThreads(blocked);
3429 return tuple;
3430 }
3431 else
3432 RETURN_NONE();
3433 }
3434 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3435 return wxFileType::ExpandCommand(command,
3436 wxFileType::MessageParameters(filename, mimetype));
3437 }
3438 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3439 wxArrayString arr;
3440 self->EnumAllFileTypes(arr);
3441 return wxArrayString2PyList_helper(arr);
3442 }
3443
3444 #include <wx/artprov.h>
3445
3446 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3447 static const wxString wxPyART_MENU(wxART_MENU);
3448 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3449 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3450 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3451 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3452 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3453 static const wxString wxPyART_OTHER(wxART_OTHER);
3454 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3455 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3456 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3457 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3458 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3459 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3460 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3461 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3462 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3463 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3464 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3465 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3466 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3467 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3468 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3469 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3470 static const wxString wxPyART_PRINT(wxART_PRINT);
3471 static const wxString wxPyART_HELP(wxART_HELP);
3472 static const wxString wxPyART_TIP(wxART_TIP);
3473 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3474 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3475 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3476 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3477 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3478 static const wxString wxPyART_CDROM(wxART_CDROM);
3479 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3480 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3481 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3482 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3483 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3484 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3485 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3486 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3487 static const wxString wxPyART_ERROR(wxART_ERROR);
3488 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3489 static const wxString wxPyART_WARNING(wxART_WARNING);
3490 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3491 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3492 static const wxString wxPyART_COPY(wxART_COPY);
3493 static const wxString wxPyART_CUT(wxART_CUT);
3494 static const wxString wxPyART_PASTE(wxART_PASTE);
3495 static const wxString wxPyART_DELETE(wxART_DELETE);
3496 static const wxString wxPyART_NEW(wxART_NEW);
3497 static const wxString wxPyART_UNDO(wxART_UNDO);
3498 static const wxString wxPyART_REDO(wxART_REDO);
3499 static const wxString wxPyART_QUIT(wxART_QUIT);
3500 static const wxString wxPyART_FIND(wxART_FIND);
3501 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3502 // Python aware wxArtProvider
3503 class wxPyArtProvider : public wxArtProvider {
3504 public:
3505
3506 virtual wxBitmap CreateBitmap(const wxArtID& id,
3507 const wxArtClient& client,
3508 const wxSize& size) {
3509 wxBitmap rval = wxNullBitmap;
3510 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3511 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3512 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3513 PyObject* ro;
3514 wxBitmap* ptr;
3515 PyObject* s1, *s2;
3516 s1 = wx2PyString(id);
3517 s2 = wx2PyString(client);
3518 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3519 Py_DECREF(so);
3520 Py_DECREF(s1);
3521 Py_DECREF(s2);
3522 if (ro) {
3523 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3524 rval = *ptr;
3525 Py_DECREF(ro);
3526 }
3527 }
3528 wxPyEndBlockThreads(blocked);
3529 return rval;
3530 }
3531
3532 PYPRIVATE;
3533 };
3534
3535 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3536
3537
3538
3539 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3540 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3541 PyObject* ret = PyTuple_New(3);
3542 if (ret) {
3543 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3544 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3545 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3546 }
3547 wxPyEndBlockThreads(blocked);
3548 return ret;
3549 }
3550
3551 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3552 bool cont;
3553 long index = 0;
3554 wxString value;
3555
3556 cont = self->GetFirstGroup(value, index);
3557 return __EnumerationHelper(cont, value, index);
3558 }
3559 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3560 bool cont;
3561 wxString value;
3562
3563 cont = self->GetNextGroup(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3567 bool cont;
3568 long index = 0;
3569 wxString value;
3570
3571 cont = self->GetFirstEntry(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3575 bool cont;
3576 wxString value;
3577
3578 cont = self->GetNextEntry(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3582 long rv;
3583 self->Read(key, &rv, defaultVal);
3584 return rv;
3585 }
3586
3587 SWIGINTERN int
3588 SWIG_AsVal_double (PyObject *obj, double* val)
3589 {
3590 if (PyNumber_Check(obj)) {
3591 if (val) *val = PyFloat_AsDouble(obj);
3592 return SWIG_OK;
3593 }
3594 return SWIG_TypeError;
3595 }
3596
3597 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3598 double rv;
3599 self->Read(key, &rv, defaultVal);
3600 return rv;
3601 }
3602
3603 #define SWIG_From_double PyFloat_FromDouble
3604
3605 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3606 bool rv;
3607 self->Read(key, &rv, defaultVal);
3608 return rv;
3609 }
3610
3611 #include <wx/datetime.h>
3612
3613 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3614 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3615
3616 #define LOCAL_TZ wxDateTime::Local
3617
3618 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3619 wxString am;
3620 wxString pm;
3621 wxDateTime::GetAmPmStrings(&am, &pm);
3622 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3623 PyObject* tup = PyTuple_New(2);
3624 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3625 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3626 wxPyEndBlockThreads(blocked);
3627 return tup;
3628 }
3629
3630 SWIGINTERNINLINE PyObject *
3631 SWIG_From_unsigned_SS_int (unsigned int value)
3632 {
3633 return SWIG_From_unsigned_SS_long (value);
3634 }
3635
3636 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3637 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3638 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3639 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3640 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3641 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3642 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3643 return (*self < *other);
3644 }
3645 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3646 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3647 return (*self <= *other);
3648 }
3649 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3651 return (*self > *other);
3652 }
3653 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3655 return (*self >= *other);
3656 }
3657 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3659 return (*self == *other);
3660 }
3661 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3662 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3663 return (*self != *other);
3664 }
3665 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3666 const wxChar* rv;
3667 const wxChar* _date = date;
3668 rv = self->ParseRfc822Date(_date);
3669 if (rv == NULL) return -1;
3670 return rv - _date;
3671 }
3672 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3673 const wxChar* rv;
3674 const wxChar* _date = date;
3675 rv = self->ParseFormat(_date, format, dateDef);
3676 if (rv == NULL) return -1;
3677 return rv - _date;
3678 }
3679 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3680 const wxChar* rv;
3681 const wxChar* _datetime = datetime;
3682 rv = self->ParseDateTime(_datetime);
3683 if (rv == NULL) return -1;
3684 return rv - _datetime;
3685 }
3686 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3687 const wxChar* rv;
3688 const wxChar* _date = date;
3689 rv = self->ParseDate(_date);
3690 if (rv == NULL) return -1;
3691 return rv - _date;
3692 }
3693 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3694 const wxChar* rv;
3695 const wxChar* _time = time;
3696 rv = self->ParseTime(_time);
3697 if (rv == NULL) return -1;
3698 return rv - _time;
3699 }
3700 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3704 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3705 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3706 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3707 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3708 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3709 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3710 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3711 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3712 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3713 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3714 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3715 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3716
3717 #include <wx/dataobj.h>
3718
3719 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3720 size_t count = self->GetFormatCount(dir);
3721 wxDataFormat* formats = new wxDataFormat[count];
3722 self->GetAllFormats(formats, dir);
3723
3724 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3725 PyObject* list = PyList_New(count);
3726 for (size_t i=0; i<count; i++) {
3727 wxDataFormat* format = new wxDataFormat(formats[i]);
3728 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3729 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3730 }
3731 wxPyEndBlockThreads(blocked);
3732 delete [] formats;
3733 return list;
3734 }
3735 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3736 PyObject* rval = NULL;
3737 size_t size = self->GetDataSize(format);
3738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3739 if (size) {
3740 char* buf = new char[size];
3741 if (self->GetDataHere(format, buf))
3742 rval = PyString_FromStringAndSize(buf, size);
3743 delete [] buf;
3744 }
3745 if (! rval) {
3746 rval = Py_None;
3747 Py_INCREF(rval);
3748 }
3749 wxPyEndBlockThreads(blocked);
3750 return rval;
3751 }
3752 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3753 bool rval;
3754 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3755 if (PyString_Check(data)) {
3756 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3757 }
3758 else {
3759 // raise a TypeError if not a string
3760 PyErr_SetString(PyExc_TypeError, "String expected.");
3761 rval = false;
3762 }
3763 wxPyEndBlockThreads(blocked);
3764 return rval;
3765 }
3766 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3767 PyObject* rval = NULL;
3768 size_t size = self->GetDataSize();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 if (size) {
3771 char* buf = new char[size];
3772 if (self->GetDataHere(buf))
3773 rval = PyString_FromStringAndSize(buf, size);
3774 delete [] buf;
3775 }
3776 if (! rval) {
3777 rval = Py_None;
3778 Py_INCREF(rval);
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return rval;
3782 }
3783 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3784 bool rval;
3785 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3786 if (PyString_Check(data)) {
3787 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3788 }
3789 else {
3790 // raise a TypeError if not a string
3791 PyErr_SetString(PyExc_TypeError, "String expected.");
3792 rval = false;
3793 }
3794 wxPyEndBlockThreads(blocked);
3795 return rval;
3796 }
3797 // Create a new class for wxPython to use
3798 class wxPyDataObjectSimple : public wxDataObjectSimple {
3799 public:
3800 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3801 : wxDataObjectSimple(format) {}
3802
3803 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3804 bool GetDataHere(void *buf) const;
3805 bool SetData(size_t len, const void *buf) const;
3806 PYPRIVATE;
3807 };
3808
3809 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3810
3811 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3812 // We need to get the data for this object and write it to buf. I think
3813 // the best way to do this for wxPython is to have the Python method
3814 // return either a string or None and then act appropriately with the
3815 // C++ version.
3816
3817 bool rval = false;
3818 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3819 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3820 PyObject* ro;
3821 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3822 if (ro) {
3823 rval = (ro != Py_None && PyString_Check(ro));
3824 if (rval)
3825 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3826 Py_DECREF(ro);
3827 }
3828 }
3829 wxPyEndBlockThreads(blocked);
3830 return rval;
3831 }
3832
3833 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3834 // For this one we simply need to make a string from buf and len
3835 // and send it to the Python method.
3836 bool rval = false;
3837 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3838 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3839 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3840 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3841 Py_DECREF(data);
3842 }
3843 wxPyEndBlockThreads(blocked);
3844 return rval;
3845 }
3846
3847 // Create a new class for wxPython to use
3848 class wxPyTextDataObject : public wxTextDataObject {
3849 public:
3850 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3851 : wxTextDataObject(text) {}
3852
3853 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3854 DEC_PYCALLBACK_STRING__const(GetText);
3855 DEC_PYCALLBACK__STRING(SetText);
3856 PYPRIVATE;
3857 };
3858
3859 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3860 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3861 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3862
3863
3864 // Create a new class for wxPython to use
3865 class wxPyBitmapDataObject : public wxBitmapDataObject {
3866 public:
3867 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3868 : wxBitmapDataObject(bitmap) {}
3869
3870 wxBitmap GetBitmap() const;
3871 void SetBitmap(const wxBitmap& bitmap);
3872 PYPRIVATE;
3873 };
3874
3875 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3876 wxBitmap* rval = &wxNullBitmap;
3877 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3878 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3879 PyObject* ro;
3880 wxBitmap* ptr;
3881 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3882 if (ro) {
3883 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3884 rval = ptr;
3885 Py_DECREF(ro);
3886 }
3887 }
3888 wxPyEndBlockThreads(blocked);
3889 return *rval;
3890 }
3891
3892 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3893 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3894 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3895 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3896 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3897 Py_DECREF(bo);
3898 }
3899 wxPyEndBlockThreads(blocked);
3900 }
3901
3902 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3903 return new wxCustomDataObject(wxDataFormat(formatName));
3904 }
3905 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3906 bool rval;
3907 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3908 if (PyString_Check(data)) {
3909 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3910 }
3911 else {
3912 // raise a TypeError if not a string
3913 PyErr_SetString(PyExc_TypeError, "String expected.");
3914 rval = false;
3915 }
3916 wxPyEndBlockThreads(blocked);
3917 return rval;
3918 }
3919 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3920 PyObject* obj;
3921 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3922 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3923 wxPyEndBlockThreads(blocked);
3924 return obj;
3925 }
3926
3927 #include <wx/metafile.h>
3928
3929
3930 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3931
3932
3933 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3934 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3935 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3936 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3937 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3938
3939
3940 class wxPyTextDropTarget : public wxTextDropTarget {
3941 public:
3942 wxPyTextDropTarget() {}
3943
3944 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3945
3946 DEC_PYCALLBACK__(OnLeave);
3947 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3950 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3951
3952 PYPRIVATE;
3953 };
3954
3955 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3956 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3957 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3960 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3961
3962
3963
3964 class wxPyFileDropTarget : public wxFileDropTarget {
3965 public:
3966 wxPyFileDropTarget() {}
3967
3968 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3969
3970 DEC_PYCALLBACK__(OnLeave);
3971 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3974 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3975
3976 PYPRIVATE;
3977 };
3978
3979 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3980 const wxArrayString& filenames) {
3981 bool rval = false;
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3984 PyObject* list = wxArrayString2PyList_helper(filenames);
3985 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3986 Py_DECREF(list);
3987 }
3988 wxPyEndBlockThreads(blocked);
3989 return rval;
3990 }
3991
3992
3993
3994 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3995 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3998 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3999
4000
4001
4002
4003 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4004
4005 #include <wx/display.h>
4006
4007 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4008 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4009
4010 #if !wxUSE_DISPLAY
4011 const wxVideoMode wxDefaultVideoMode;
4012 #endif
4013
4014 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4015 #if wxUSE_DISPLAY
4016 PyObject* pyList = NULL;
4017 wxArrayVideoModes arr = self->GetModes(mode);
4018 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4019 pyList = PyList_New(0);
4020 for (size_t i=0; i < arr.GetCount(); i++)
4021 {
4022 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4023 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4024 PyList_Append(pyList, pyObj);
4025 Py_DECREF(pyObj);
4026 }
4027 wxPyEndBlockThreads(blocked);
4028 return pyList;
4029 #else
4030 wxPyRaiseNotImplemented();
4031 return NULL;
4032 #endif
4033 }
4034 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4035 #if wxUSE_DISPLAY
4036 return self->GetCurrentMode();
4037 #else
4038 wxPyRaiseNotImplemented();
4039 return wxDefaultVideoMode;
4040 #endif
4041 }
4042 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4043 #if wxUSE_DISPLAY
4044 return self->ChangeMode(mode);
4045 #else
4046 wxPyRaiseNotImplemented();
4047 return false;
4048 #endif
4049 }
4050 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4051 #if wxUSE_DISPLAY
4052 self->ResetMode();
4053 #else
4054 wxPyRaiseNotImplemented();
4055 #endif
4056 }
4057
4058 #include <wx/stdpaths.h>
4059
4060 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4061 return (wxStandardPaths*) &wxStandardPaths::Get();
4062 }
4063 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4064 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4065
4066 #ifndef wxHAS_POWER_EVENTS
4067 // Dummy class and other definitions for platforms that don't have them
4068
4069 // See wxPython_int.h for wxPowerEvent
4070
4071 enum {
4072 wxEVT_POWER_SUSPENDING,
4073 wxEVT_POWER_SUSPENDED,
4074 wxEVT_POWER_SUSPEND_CANCEL,
4075 wxEVT_POWER_RESUME,
4076 };
4077
4078 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4079 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4080
4081 #endif
4082
4083 #ifdef __cplusplus
4084 extern "C" {
4085 #endif
4086 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4087 PyObject *resultobj = 0;
4088 wxSystemColour arg1 ;
4089 wxColour result;
4090 int val1 ;
4091 int ecode1 = 0 ;
4092 PyObject * obj0 = 0 ;
4093 char * kwnames[] = {
4094 (char *) "index", NULL
4095 };
4096
4097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4098 ecode1 = SWIG_AsVal_int(obj0, &val1);
4099 if (!SWIG_IsOK(ecode1)) {
4100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4101 }
4102 arg1 = static_cast< wxSystemColour >(val1);
4103 {
4104 if (!wxPyCheckForApp()) SWIG_fail;
4105 PyThreadState* __tstate = wxPyBeginAllowThreads();
4106 result = wxSystemSettings::GetColour(arg1);
4107 wxPyEndAllowThreads(__tstate);
4108 if (PyErr_Occurred()) SWIG_fail;
4109 }
4110 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4111 return resultobj;
4112 fail:
4113 return NULL;
4114 }
4115
4116
4117 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4118 PyObject *resultobj = 0;
4119 wxSystemFont arg1 ;
4120 wxFont result;
4121 int val1 ;
4122 int ecode1 = 0 ;
4123 PyObject * obj0 = 0 ;
4124 char * kwnames[] = {
4125 (char *) "index", NULL
4126 };
4127
4128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4129 ecode1 = SWIG_AsVal_int(obj0, &val1);
4130 if (!SWIG_IsOK(ecode1)) {
4131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4132 }
4133 arg1 = static_cast< wxSystemFont >(val1);
4134 {
4135 if (!wxPyCheckForApp()) SWIG_fail;
4136 PyThreadState* __tstate = wxPyBeginAllowThreads();
4137 result = wxSystemSettings::GetFont(arg1);
4138 wxPyEndAllowThreads(__tstate);
4139 if (PyErr_Occurred()) SWIG_fail;
4140 }
4141 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj = 0;
4150 wxSystemMetric arg1 ;
4151 wxWindow *arg2 = (wxWindow *) NULL ;
4152 int result;
4153 int val1 ;
4154 int ecode1 = 0 ;
4155 void *argp2 = 0 ;
4156 int res2 = 0 ;
4157 PyObject * obj0 = 0 ;
4158 PyObject * obj1 = 0 ;
4159 char * kwnames[] = {
4160 (char *) "index",(char *) "win", NULL
4161 };
4162
4163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4164 ecode1 = SWIG_AsVal_int(obj0, &val1);
4165 if (!SWIG_IsOK(ecode1)) {
4166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4167 }
4168 arg1 = static_cast< wxSystemMetric >(val1);
4169 if (obj1) {
4170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4171 if (!SWIG_IsOK(res2)) {
4172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4173 }
4174 arg2 = reinterpret_cast< wxWindow * >(argp2);
4175 }
4176 {
4177 if (!wxPyCheckForApp()) SWIG_fail;
4178 PyThreadState* __tstate = wxPyBeginAllowThreads();
4179 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4180 wxPyEndAllowThreads(__tstate);
4181 if (PyErr_Occurred()) SWIG_fail;
4182 }
4183 resultobj = SWIG_From_int(static_cast< int >(result));
4184 return resultobj;
4185 fail:
4186 return NULL;
4187 }
4188
4189
4190 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4191 PyObject *resultobj = 0;
4192 wxSystemFeature arg1 ;
4193 bool result;
4194 int val1 ;
4195 int ecode1 = 0 ;
4196 PyObject * obj0 = 0 ;
4197 char * kwnames[] = {
4198 (char *) "index", NULL
4199 };
4200
4201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4202 ecode1 = SWIG_AsVal_int(obj0, &val1);
4203 if (!SWIG_IsOK(ecode1)) {
4204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4205 }
4206 arg1 = static_cast< wxSystemFeature >(val1);
4207 {
4208 if (!wxPyCheckForApp()) SWIG_fail;
4209 PyThreadState* __tstate = wxPyBeginAllowThreads();
4210 result = (bool)wxSystemSettings::HasFeature(arg1);
4211 wxPyEndAllowThreads(__tstate);
4212 if (PyErr_Occurred()) SWIG_fail;
4213 }
4214 {
4215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4216 }
4217 return resultobj;
4218 fail:
4219 return NULL;
4220 }
4221
4222
4223 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4224 PyObject *resultobj = 0;
4225 wxSystemScreenType result;
4226
4227 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4228 {
4229 if (!wxPyCheckForApp()) SWIG_fail;
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 resultobj = SWIG_From_int(static_cast< int >(result));
4236 return resultobj;
4237 fail:
4238 return NULL;
4239 }
4240
4241
4242 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4243 PyObject *resultobj = 0;
4244 wxSystemScreenType arg1 ;
4245 int val1 ;
4246 int ecode1 = 0 ;
4247 PyObject * obj0 = 0 ;
4248 char * kwnames[] = {
4249 (char *) "screen", NULL
4250 };
4251
4252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4253 ecode1 = SWIG_AsVal_int(obj0, &val1);
4254 if (!SWIG_IsOK(ecode1)) {
4255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4256 }
4257 arg1 = static_cast< wxSystemScreenType >(val1);
4258 {
4259 if (!wxPyCheckForApp()) SWIG_fail;
4260 PyThreadState* __tstate = wxPyBeginAllowThreads();
4261 wxSystemSettings::SetScreenType(arg1);
4262 wxPyEndAllowThreads(__tstate);
4263 if (PyErr_Occurred()) SWIG_fail;
4264 }
4265 resultobj = SWIG_Py_Void();
4266 return resultobj;
4267 fail:
4268 return NULL;
4269 }
4270
4271
4272 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4273 PyObject *obj;
4274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4275 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4276 return SWIG_Py_Void();
4277 }
4278
4279 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4280 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4281 return 1;
4282 }
4283
4284
4285 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4286 PyObject *pyobj = 0;
4287
4288 {
4289 #if wxUSE_UNICODE
4290 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4291 #else
4292 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4293 #endif
4294 }
4295 return pyobj;
4296 }
4297
4298
4299 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4300 PyObject *resultobj = 0;
4301 wxSystemOptions *result = 0 ;
4302
4303 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4304 {
4305 PyThreadState* __tstate = wxPyBeginAllowThreads();
4306 result = (wxSystemOptions *)new wxSystemOptions();
4307 wxPyEndAllowThreads(__tstate);
4308 if (PyErr_Occurred()) SWIG_fail;
4309 }
4310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4311 return resultobj;
4312 fail:
4313 return NULL;
4314 }
4315
4316
4317 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4318 PyObject *resultobj = 0;
4319 wxString *arg1 = 0 ;
4320 wxString *arg2 = 0 ;
4321 bool temp1 = false ;
4322 bool temp2 = false ;
4323 PyObject * obj0 = 0 ;
4324 PyObject * obj1 = 0 ;
4325 char * kwnames[] = {
4326 (char *) "name",(char *) "value", NULL
4327 };
4328
4329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4330 {
4331 arg1 = wxString_in_helper(obj0);
4332 if (arg1 == NULL) SWIG_fail;
4333 temp1 = true;
4334 }
4335 {
4336 arg2 = wxString_in_helper(obj1);
4337 if (arg2 == NULL) SWIG_fail;
4338 temp2 = true;
4339 }
4340 {
4341 PyThreadState* __tstate = wxPyBeginAllowThreads();
4342 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4343 wxPyEndAllowThreads(__tstate);
4344 if (PyErr_Occurred()) SWIG_fail;
4345 }
4346 resultobj = SWIG_Py_Void();
4347 {
4348 if (temp1)
4349 delete arg1;
4350 }
4351 {
4352 if (temp2)
4353 delete arg2;
4354 }
4355 return resultobj;
4356 fail:
4357 {
4358 if (temp1)
4359 delete arg1;
4360 }
4361 {
4362 if (temp2)
4363 delete arg2;
4364 }
4365 return NULL;
4366 }
4367
4368
4369 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4370 PyObject *resultobj = 0;
4371 wxString *arg1 = 0 ;
4372 int arg2 ;
4373 bool temp1 = false ;
4374 int val2 ;
4375 int ecode2 = 0 ;
4376 PyObject * obj0 = 0 ;
4377 PyObject * obj1 = 0 ;
4378 char * kwnames[] = {
4379 (char *) "name",(char *) "value", NULL
4380 };
4381
4382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4383 {
4384 arg1 = wxString_in_helper(obj0);
4385 if (arg1 == NULL) SWIG_fail;
4386 temp1 = true;
4387 }
4388 ecode2 = SWIG_AsVal_int(obj1, &val2);
4389 if (!SWIG_IsOK(ecode2)) {
4390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4391 }
4392 arg2 = static_cast< int >(val2);
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4396 wxPyEndAllowThreads(__tstate);
4397 if (PyErr_Occurred()) SWIG_fail;
4398 }
4399 resultobj = SWIG_Py_Void();
4400 {
4401 if (temp1)
4402 delete arg1;
4403 }
4404 return resultobj;
4405 fail:
4406 {
4407 if (temp1)
4408 delete arg1;
4409 }
4410 return NULL;
4411 }
4412
4413
4414 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4415 PyObject *resultobj = 0;
4416 wxString *arg1 = 0 ;
4417 wxString result;
4418 bool temp1 = false ;
4419 PyObject * obj0 = 0 ;
4420 char * kwnames[] = {
4421 (char *) "name", NULL
4422 };
4423
4424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4425 {
4426 arg1 = wxString_in_helper(obj0);
4427 if (arg1 == NULL) SWIG_fail;
4428 temp1 = true;
4429 }
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 #if wxUSE_UNICODE
4438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4439 #else
4440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4441 #endif
4442 }
4443 {
4444 if (temp1)
4445 delete arg1;
4446 }
4447 return resultobj;
4448 fail:
4449 {
4450 if (temp1)
4451 delete arg1;
4452 }
4453 return NULL;
4454 }
4455
4456
4457 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4458 PyObject *resultobj = 0;
4459 wxString *arg1 = 0 ;
4460 int result;
4461 bool temp1 = false ;
4462 PyObject * obj0 = 0 ;
4463 char * kwnames[] = {
4464 (char *) "name", NULL
4465 };
4466
4467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4468 {
4469 arg1 = wxString_in_helper(obj0);
4470 if (arg1 == NULL) SWIG_fail;
4471 temp1 = true;
4472 }
4473 {
4474 PyThreadState* __tstate = wxPyBeginAllowThreads();
4475 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4476 wxPyEndAllowThreads(__tstate);
4477 if (PyErr_Occurred()) SWIG_fail;
4478 }
4479 resultobj = SWIG_From_int(static_cast< int >(result));
4480 {
4481 if (temp1)
4482 delete arg1;
4483 }
4484 return resultobj;
4485 fail:
4486 {
4487 if (temp1)
4488 delete arg1;
4489 }
4490 return NULL;
4491 }
4492
4493
4494 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj = 0;
4496 wxString *arg1 = 0 ;
4497 bool result;
4498 bool temp1 = false ;
4499 PyObject * obj0 = 0 ;
4500 char * kwnames[] = {
4501 (char *) "name", NULL
4502 };
4503
4504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4505 {
4506 arg1 = wxString_in_helper(obj0);
4507 if (arg1 == NULL) SWIG_fail;
4508 temp1 = true;
4509 }
4510 {
4511 PyThreadState* __tstate = wxPyBeginAllowThreads();
4512 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4513 wxPyEndAllowThreads(__tstate);
4514 if (PyErr_Occurred()) SWIG_fail;
4515 }
4516 {
4517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4518 }
4519 {
4520 if (temp1)
4521 delete arg1;
4522 }
4523 return resultobj;
4524 fail:
4525 {
4526 if (temp1)
4527 delete arg1;
4528 }
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4534 PyObject *resultobj = 0;
4535 wxString *arg1 = 0 ;
4536 bool result;
4537 bool temp1 = false ;
4538 PyObject * obj0 = 0 ;
4539 char * kwnames[] = {
4540 (char *) "name", NULL
4541 };
4542
4543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4544 {
4545 arg1 = wxString_in_helper(obj0);
4546 if (arg1 == NULL) SWIG_fail;
4547 temp1 = true;
4548 }
4549 {
4550 PyThreadState* __tstate = wxPyBeginAllowThreads();
4551 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4552 wxPyEndAllowThreads(__tstate);
4553 if (PyErr_Occurred()) SWIG_fail;
4554 }
4555 {
4556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4557 }
4558 {
4559 if (temp1)
4560 delete arg1;
4561 }
4562 return resultobj;
4563 fail:
4564 {
4565 if (temp1)
4566 delete arg1;
4567 }
4568 return NULL;
4569 }
4570
4571
4572 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573 PyObject *obj;
4574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4575 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4576 return SWIG_Py_Void();
4577 }
4578
4579 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580 return SWIG_Python_InitShadowInstance(args);
4581 }
4582
4583 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4584 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4585 return 1;
4586 }
4587
4588
4589 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4590 PyObject *pyobj = 0;
4591
4592 {
4593 #if wxUSE_UNICODE
4594 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4595 #else
4596 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4597 #endif
4598 }
4599 return pyobj;
4600 }
4601
4602
4603 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4604 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4605 return 1;
4606 }
4607
4608
4609 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4610 PyObject *pyobj = 0;
4611
4612 {
4613 #if wxUSE_UNICODE
4614 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4615 #else
4616 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4617 #endif
4618 }
4619 return pyobj;
4620 }
4621
4622
4623 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4624 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4625 return 1;
4626 }
4627
4628
4629 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4630 PyObject *pyobj = 0;
4631
4632 {
4633 #if wxUSE_UNICODE
4634 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4635 #else
4636 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4637 #endif
4638 }
4639 return pyobj;
4640 }
4641
4642
4643 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4644 PyObject *resultobj = 0;
4645 long result;
4646
4647 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4648 {
4649 PyThreadState* __tstate = wxPyBeginAllowThreads();
4650 result = (long)wxNewId();
4651 wxPyEndAllowThreads(__tstate);
4652 if (PyErr_Occurred()) SWIG_fail;
4653 }
4654 resultobj = SWIG_From_long(static_cast< long >(result));
4655 return resultobj;
4656 fail:
4657 return NULL;
4658 }
4659
4660
4661 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4662 PyObject *resultobj = 0;
4663 long arg1 ;
4664 long val1 ;
4665 int ecode1 = 0 ;
4666 PyObject * obj0 = 0 ;
4667 char * kwnames[] = {
4668 (char *) "id", NULL
4669 };
4670
4671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4672 ecode1 = SWIG_AsVal_long(obj0, &val1);
4673 if (!SWIG_IsOK(ecode1)) {
4674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4675 }
4676 arg1 = static_cast< long >(val1);
4677 {
4678 PyThreadState* __tstate = wxPyBeginAllowThreads();
4679 wxRegisterId(arg1);
4680 wxPyEndAllowThreads(__tstate);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 resultobj = SWIG_Py_Void();
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4691 PyObject *resultobj = 0;
4692 long result;
4693
4694 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4695 {
4696 PyThreadState* __tstate = wxPyBeginAllowThreads();
4697 result = (long)wxGetCurrentId();
4698 wxPyEndAllowThreads(__tstate);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 resultobj = SWIG_From_long(static_cast< long >(result));
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = 0;
4710 int arg1 ;
4711 bool result;
4712 int val1 ;
4713 int ecode1 = 0 ;
4714 PyObject * obj0 = 0 ;
4715 char * kwnames[] = {
4716 (char *) "id", NULL
4717 };
4718
4719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4720 ecode1 = SWIG_AsVal_int(obj0, &val1);
4721 if (!SWIG_IsOK(ecode1)) {
4722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4723 }
4724 arg1 = static_cast< int >(val1);
4725 {
4726 PyThreadState* __tstate = wxPyBeginAllowThreads();
4727 result = (bool)wxIsStockID(arg1);
4728 wxPyEndAllowThreads(__tstate);
4729 if (PyErr_Occurred()) SWIG_fail;
4730 }
4731 {
4732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4733 }
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj = 0;
4742 int arg1 ;
4743 wxString *arg2 = 0 ;
4744 bool result;
4745 int val1 ;
4746 int ecode1 = 0 ;
4747 bool temp2 = false ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
4751 (char *) "id",(char *) "label", NULL
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4755 ecode1 = SWIG_AsVal_int(obj0, &val1);
4756 if (!SWIG_IsOK(ecode1)) {
4757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4758 }
4759 arg1 = static_cast< int >(val1);
4760 {
4761 arg2 = wxString_in_helper(obj1);
4762 if (arg2 == NULL) SWIG_fail;
4763 temp2 = true;
4764 }
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 {
4772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4773 }
4774 {
4775 if (temp2)
4776 delete arg2;
4777 }
4778 return resultobj;
4779 fail:
4780 {
4781 if (temp2)
4782 delete arg2;
4783 }
4784 return NULL;
4785 }
4786
4787
4788 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4789 PyObject *resultobj = 0;
4790 int arg1 ;
4791 bool arg2 = (bool) true ;
4792 wxString arg3 = (wxString) wxPyEmptyString ;
4793 wxString result;
4794 int val1 ;
4795 int ecode1 = 0 ;
4796 bool val2 ;
4797 int ecode2 = 0 ;
4798 PyObject * obj0 = 0 ;
4799 PyObject * obj1 = 0 ;
4800 PyObject * obj2 = 0 ;
4801 char * kwnames[] = {
4802 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4803 };
4804
4805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4806 ecode1 = SWIG_AsVal_int(obj0, &val1);
4807 if (!SWIG_IsOK(ecode1)) {
4808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4809 }
4810 arg1 = static_cast< int >(val1);
4811 if (obj1) {
4812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4813 if (!SWIG_IsOK(ecode2)) {
4814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4815 }
4816 arg2 = static_cast< bool >(val2);
4817 }
4818 if (obj2) {
4819 {
4820 wxString* sptr = wxString_in_helper(obj2);
4821 if (sptr == NULL) SWIG_fail;
4822 arg3 = *sptr;
4823 delete sptr;
4824 }
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 result = wxGetStockLabel(arg1,arg2,arg3);
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 {
4833 #if wxUSE_UNICODE
4834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4835 #else
4836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4837 #endif
4838 }
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846 PyObject *resultobj = 0;
4847
4848 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4849 {
4850 if (!wxPyCheckForApp()) SWIG_fail;
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 wxBell();
4853 wxPyEndAllowThreads(__tstate);
4854 if (PyErr_Occurred()) SWIG_fail;
4855 }
4856 resultobj = SWIG_Py_Void();
4857 return resultobj;
4858 fail:
4859 return NULL;
4860 }
4861
4862
4863 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4864 PyObject *resultobj = 0;
4865
4866 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4867 {
4868 if (!wxPyCheckForApp()) SWIG_fail;
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 wxEndBusyCursor();
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 resultobj = SWIG_Py_Void();
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 bool arg1 = (bool) true ;
4884 long result;
4885 bool val1 ;
4886 int ecode1 = 0 ;
4887 PyObject * obj0 = 0 ;
4888 char * kwnames[] = {
4889 (char *) "resetTimer", NULL
4890 };
4891
4892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4893 if (obj0) {
4894 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4895 if (!SWIG_IsOK(ecode1)) {
4896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4897 }
4898 arg1 = static_cast< bool >(val1);
4899 }
4900 {
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 result = (long)wxGetElapsedTime(arg1);
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_From_long(static_cast< long >(result));
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4914 PyObject *resultobj = 0;
4915 bool result;
4916
4917 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4918 {
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 result = (bool)wxIsBusy();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 {
4925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4926 }
4927 return resultobj;
4928 fail:
4929 return NULL;
4930 }
4931
4932
4933 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4934 PyObject *resultobj = 0;
4935 wxString result;
4936
4937 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4938 {
4939 PyThreadState* __tstate = wxPyBeginAllowThreads();
4940 result = wxNow();
4941 wxPyEndAllowThreads(__tstate);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 {
4945 #if wxUSE_UNICODE
4946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4947 #else
4948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4949 #endif
4950 }
4951 return resultobj;
4952 fail:
4953 return NULL;
4954 }
4955
4956
4957 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4958 PyObject *resultobj = 0;
4959 wxString const &arg1_defvalue = wxPyEmptyString ;
4960 wxString *arg1 = (wxString *) &arg1_defvalue ;
4961 bool result;
4962 bool temp1 = false ;
4963 PyObject * obj0 = 0 ;
4964 char * kwnames[] = {
4965 (char *) "command", NULL
4966 };
4967
4968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4969 if (obj0) {
4970 {
4971 arg1 = wxString_in_helper(obj0);
4972 if (arg1 == NULL) SWIG_fail;
4973 temp1 = true;
4974 }
4975 }
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (bool)wxShell((wxString const &)*arg1);
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4984 }
4985 {
4986 if (temp1)
4987 delete arg1;
4988 }
4989 return resultobj;
4990 fail:
4991 {
4992 if (temp1)
4993 delete arg1;
4994 }
4995 return NULL;
4996 }
4997
4998
4999 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5000 PyObject *resultobj = 0;
5001
5002 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5003 {
5004 PyThreadState* __tstate = wxPyBeginAllowThreads();
5005 wxStartTimer();
5006 wxPyEndAllowThreads(__tstate);
5007 if (PyErr_Occurred()) SWIG_fail;
5008 }
5009 resultobj = SWIG_Py_Void();
5010 return resultobj;
5011 fail:
5012 return NULL;
5013 }
5014
5015
5016 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5017 PyObject *resultobj = 0;
5018 int *arg1 = (int *) 0 ;
5019 int *arg2 = (int *) 0 ;
5020 int result;
5021 int temp1 ;
5022 int res1 = SWIG_TMPOBJ ;
5023 int temp2 ;
5024 int res2 = SWIG_TMPOBJ ;
5025
5026 arg1 = &temp1;
5027 arg2 = &temp2;
5028 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5029 {
5030 PyThreadState* __tstate = wxPyBeginAllowThreads();
5031 result = (int)wxGetOsVersion(arg1,arg2);
5032 wxPyEndAllowThreads(__tstate);
5033 if (PyErr_Occurred()) SWIG_fail;
5034 }
5035 resultobj = SWIG_From_int(static_cast< int >(result));
5036 if (SWIG_IsTmpObj(res1)) {
5037 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5038 } else {
5039 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5040 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5041 }
5042 if (SWIG_IsTmpObj(res2)) {
5043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5044 } else {
5045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5047 }
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5055 PyObject *resultobj = 0;
5056 wxString result;
5057
5058 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5059 {
5060 PyThreadState* __tstate = wxPyBeginAllowThreads();
5061 result = wxGetOsDescription();
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 {
5066 #if wxUSE_UNICODE
5067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5068 #else
5069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5070 #endif
5071 }
5072 return resultobj;
5073 fail:
5074 return NULL;
5075 }
5076
5077
5078 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5079 PyObject *resultobj = 0;
5080 wxMemorySize result;
5081
5082 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 result = wxGetFreeMemory();
5086 wxPyEndAllowThreads(__tstate);
5087 if (PyErr_Occurred()) SWIG_fail;
5088 }
5089 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5097 PyObject *resultobj = 0;
5098 wxShutdownFlags arg1 ;
5099 bool result;
5100 int val1 ;
5101 int ecode1 = 0 ;
5102 PyObject * obj0 = 0 ;
5103 char * kwnames[] = {
5104 (char *) "wFlags", NULL
5105 };
5106
5107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5108 ecode1 = SWIG_AsVal_int(obj0, &val1);
5109 if (!SWIG_IsOK(ecode1)) {
5110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5111 }
5112 arg1 = static_cast< wxShutdownFlags >(val1);
5113 {
5114 if (!wxPyCheckForApp()) SWIG_fail;
5115 PyThreadState* __tstate = wxPyBeginAllowThreads();
5116 result = (bool)wxShutdown(arg1);
5117 wxPyEndAllowThreads(__tstate);
5118 if (PyErr_Occurred()) SWIG_fail;
5119 }
5120 {
5121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5122 }
5123 return resultobj;
5124 fail:
5125 return NULL;
5126 }
5127
5128
5129 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5130 PyObject *resultobj = 0;
5131 int arg1 ;
5132 int val1 ;
5133 int ecode1 = 0 ;
5134 PyObject * obj0 = 0 ;
5135 char * kwnames[] = {
5136 (char *) "secs", NULL
5137 };
5138
5139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5140 ecode1 = SWIG_AsVal_int(obj0, &val1);
5141 if (!SWIG_IsOK(ecode1)) {
5142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5143 }
5144 arg1 = static_cast< int >(val1);
5145 {
5146 PyThreadState* __tstate = wxPyBeginAllowThreads();
5147 wxSleep(arg1);
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 resultobj = SWIG_Py_Void();
5152 return resultobj;
5153 fail:
5154 return NULL;
5155 }
5156
5157
5158 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5159 PyObject *resultobj = 0;
5160 unsigned long arg1 ;
5161 unsigned long val1 ;
5162 int ecode1 = 0 ;
5163 PyObject * obj0 = 0 ;
5164 char * kwnames[] = {
5165 (char *) "milliseconds", NULL
5166 };
5167
5168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5169 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5170 if (!SWIG_IsOK(ecode1)) {
5171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5172 }
5173 arg1 = static_cast< unsigned long >(val1);
5174 {
5175 PyThreadState* __tstate = wxPyBeginAllowThreads();
5176 wxMilliSleep(arg1);
5177 wxPyEndAllowThreads(__tstate);
5178 if (PyErr_Occurred()) SWIG_fail;
5179 }
5180 resultobj = SWIG_Py_Void();
5181 return resultobj;
5182 fail:
5183 return NULL;
5184 }
5185
5186
5187 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj = 0;
5189 unsigned long arg1 ;
5190 unsigned long val1 ;
5191 int ecode1 = 0 ;
5192 PyObject * obj0 = 0 ;
5193 char * kwnames[] = {
5194 (char *) "microseconds", NULL
5195 };
5196
5197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5198 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5199 if (!SWIG_IsOK(ecode1)) {
5200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5201 }
5202 arg1 = static_cast< unsigned long >(val1);
5203 {
5204 PyThreadState* __tstate = wxPyBeginAllowThreads();
5205 wxMicroSleep(arg1);
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 resultobj = SWIG_Py_Void();
5210 return resultobj;
5211 fail:
5212 return NULL;
5213 }
5214
5215
5216 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5217 PyObject *resultobj = 0;
5218 bool arg1 ;
5219 bool val1 ;
5220 int ecode1 = 0 ;
5221 PyObject * obj0 = 0 ;
5222 char * kwnames[] = {
5223 (char *) "enable", NULL
5224 };
5225
5226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5227 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5228 if (!SWIG_IsOK(ecode1)) {
5229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5230 }
5231 arg1 = static_cast< bool >(val1);
5232 {
5233 PyThreadState* __tstate = wxPyBeginAllowThreads();
5234 wxEnableTopLevelWindows(arg1);
5235 wxPyEndAllowThreads(__tstate);
5236 if (PyErr_Occurred()) SWIG_fail;
5237 }
5238 resultobj = SWIG_Py_Void();
5239 return resultobj;
5240 fail:
5241 return NULL;
5242 }
5243
5244
5245 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5246 PyObject *resultobj = 0;
5247 wxString *arg1 = 0 ;
5248 wxString result;
5249 bool temp1 = false ;
5250 PyObject * obj0 = 0 ;
5251 char * kwnames[] = {
5252 (char *) "in", NULL
5253 };
5254
5255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5256 {
5257 arg1 = wxString_in_helper(obj0);
5258 if (arg1 == NULL) SWIG_fail;
5259 temp1 = true;
5260 }
5261 {
5262 PyThreadState* __tstate = wxPyBeginAllowThreads();
5263 result = wxStripMenuCodes((wxString const &)*arg1);
5264 wxPyEndAllowThreads(__tstate);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 {
5268 #if wxUSE_UNICODE
5269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5270 #else
5271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5272 #endif
5273 }
5274 {
5275 if (temp1)
5276 delete arg1;
5277 }
5278 return resultobj;
5279 fail:
5280 {
5281 if (temp1)
5282 delete arg1;
5283 }
5284 return NULL;
5285 }
5286
5287
5288 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5289 PyObject *resultobj = 0;
5290 wxString result;
5291
5292 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5293 {
5294 PyThreadState* __tstate = wxPyBeginAllowThreads();
5295 result = wxGetEmailAddress();
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 {
5300 #if wxUSE_UNICODE
5301 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5302 #else
5303 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5304 #endif
5305 }
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313 PyObject *resultobj = 0;
5314 wxString result;
5315
5316 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 result = wxGetHostName();
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 {
5324 #if wxUSE_UNICODE
5325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5326 #else
5327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5328 #endif
5329 }
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5337 PyObject *resultobj = 0;
5338 wxString result;
5339
5340 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5341 {
5342 PyThreadState* __tstate = wxPyBeginAllowThreads();
5343 result = wxGetFullHostName();
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 {
5348 #if wxUSE_UNICODE
5349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5350 #else
5351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5352 #endif
5353 }
5354 return resultobj;
5355 fail:
5356 return NULL;
5357 }
5358
5359
5360 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5361 PyObject *resultobj = 0;
5362 wxString result;
5363
5364 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5365 {
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 result = wxGetUserId();
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 #if wxUSE_UNICODE
5373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5374 #else
5375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5376 #endif
5377 }
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxString result;
5387
5388 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = wxGetUserName();
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 {
5396 #if wxUSE_UNICODE
5397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5398 #else
5399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5400 #endif
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5409 PyObject *resultobj = 0;
5410 wxString result;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5413 {
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 result = wxGetHomeDir();
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 #if wxUSE_UNICODE
5421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5422 #else
5423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5424 #endif
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5433 PyObject *resultobj = 0;
5434 wxString const &arg1_defvalue = wxPyEmptyString ;
5435 wxString *arg1 = (wxString *) &arg1_defvalue ;
5436 wxString result;
5437 bool temp1 = false ;
5438 PyObject * obj0 = 0 ;
5439 char * kwnames[] = {
5440 (char *) "user", NULL
5441 };
5442
5443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5444 if (obj0) {
5445 {
5446 arg1 = wxString_in_helper(obj0);
5447 if (arg1 == NULL) SWIG_fail;
5448 temp1 = true;
5449 }
5450 }
5451 {
5452 PyThreadState* __tstate = wxPyBeginAllowThreads();
5453 result = wxGetUserHome((wxString const &)*arg1);
5454 wxPyEndAllowThreads(__tstate);
5455 if (PyErr_Occurred()) SWIG_fail;
5456 }
5457 {
5458 #if wxUSE_UNICODE
5459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5460 #else
5461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5462 #endif
5463 }
5464 {
5465 if (temp1)
5466 delete arg1;
5467 }
5468 return resultobj;
5469 fail:
5470 {
5471 if (temp1)
5472 delete arg1;
5473 }
5474 return NULL;
5475 }
5476
5477
5478 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5479 PyObject *resultobj = 0;
5480 unsigned long result;
5481
5482 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5483 {
5484 PyThreadState* __tstate = wxPyBeginAllowThreads();
5485 result = (unsigned long)wxGetProcessId();
5486 wxPyEndAllowThreads(__tstate);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498
5499 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5500 {
5501 PyThreadState* __tstate = wxPyBeginAllowThreads();
5502 wxTrap();
5503 wxPyEndAllowThreads(__tstate);
5504 if (PyErr_Occurred()) SWIG_fail;
5505 }
5506 resultobj = SWIG_Py_Void();
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5514 PyObject *resultobj = 0;
5515 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5516 wxString *arg1 = (wxString *) &arg1_defvalue ;
5517 wxString const &arg2_defvalue = wxPyEmptyString ;
5518 wxString *arg2 = (wxString *) &arg2_defvalue ;
5519 wxString const &arg3_defvalue = wxPyEmptyString ;
5520 wxString *arg3 = (wxString *) &arg3_defvalue ;
5521 wxString const &arg4_defvalue = wxPyEmptyString ;
5522 wxString *arg4 = (wxString *) &arg4_defvalue ;
5523 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5524 wxString *arg5 = (wxString *) &arg5_defvalue ;
5525 int arg6 = (int) 0 ;
5526 wxWindow *arg7 = (wxWindow *) NULL ;
5527 int arg8 = (int) -1 ;
5528 int arg9 = (int) -1 ;
5529 wxString result;
5530 bool temp1 = false ;
5531 bool temp2 = false ;
5532 bool temp3 = false ;
5533 bool temp4 = false ;
5534 bool temp5 = false ;
5535 int val6 ;
5536 int ecode6 = 0 ;
5537 void *argp7 = 0 ;
5538 int res7 = 0 ;
5539 int val8 ;
5540 int ecode8 = 0 ;
5541 int val9 ;
5542 int ecode9 = 0 ;
5543 PyObject * obj0 = 0 ;
5544 PyObject * obj1 = 0 ;
5545 PyObject * obj2 = 0 ;
5546 PyObject * obj3 = 0 ;
5547 PyObject * obj4 = 0 ;
5548 PyObject * obj5 = 0 ;
5549 PyObject * obj6 = 0 ;
5550 PyObject * obj7 = 0 ;
5551 PyObject * obj8 = 0 ;
5552 char * kwnames[] = {
5553 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5554 };
5555
5556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5557 if (obj0) {
5558 {
5559 arg1 = wxString_in_helper(obj0);
5560 if (arg1 == NULL) SWIG_fail;
5561 temp1 = true;
5562 }
5563 }
5564 if (obj1) {
5565 {
5566 arg2 = wxString_in_helper(obj1);
5567 if (arg2 == NULL) SWIG_fail;
5568 temp2 = true;
5569 }
5570 }
5571 if (obj2) {
5572 {
5573 arg3 = wxString_in_helper(obj2);
5574 if (arg3 == NULL) SWIG_fail;
5575 temp3 = true;
5576 }
5577 }
5578 if (obj3) {
5579 {
5580 arg4 = wxString_in_helper(obj3);
5581 if (arg4 == NULL) SWIG_fail;
5582 temp4 = true;
5583 }
5584 }
5585 if (obj4) {
5586 {
5587 arg5 = wxString_in_helper(obj4);
5588 if (arg5 == NULL) SWIG_fail;
5589 temp5 = true;
5590 }
5591 }
5592 if (obj5) {
5593 ecode6 = SWIG_AsVal_int(obj5, &val6);
5594 if (!SWIG_IsOK(ecode6)) {
5595 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5596 }
5597 arg6 = static_cast< int >(val6);
5598 }
5599 if (obj6) {
5600 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5601 if (!SWIG_IsOK(res7)) {
5602 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5603 }
5604 arg7 = reinterpret_cast< wxWindow * >(argp7);
5605 }
5606 if (obj7) {
5607 ecode8 = SWIG_AsVal_int(obj7, &val8);
5608 if (!SWIG_IsOK(ecode8)) {
5609 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5610 }
5611 arg8 = static_cast< int >(val8);
5612 }
5613 if (obj8) {
5614 ecode9 = SWIG_AsVal_int(obj8, &val9);
5615 if (!SWIG_IsOK(ecode9)) {
5616 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5617 }
5618 arg9 = static_cast< int >(val9);
5619 }
5620 {
5621 if (!wxPyCheckForApp()) SWIG_fail;
5622 PyThreadState* __tstate = wxPyBeginAllowThreads();
5623 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5624 wxPyEndAllowThreads(__tstate);
5625 if (PyErr_Occurred()) SWIG_fail;
5626 }
5627 {
5628 #if wxUSE_UNICODE
5629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5630 #else
5631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5632 #endif
5633 }
5634 {
5635 if (temp1)
5636 delete arg1;
5637 }
5638 {
5639 if (temp2)
5640 delete arg2;
5641 }
5642 {
5643 if (temp3)
5644 delete arg3;
5645 }
5646 {
5647 if (temp4)
5648 delete arg4;
5649 }
5650 {
5651 if (temp5)
5652 delete arg5;
5653 }
5654 return resultobj;
5655 fail:
5656 {
5657 if (temp1)
5658 delete arg1;
5659 }
5660 {
5661 if (temp2)
5662 delete arg2;
5663 }
5664 {
5665 if (temp3)
5666 delete arg3;
5667 }
5668 {
5669 if (temp4)
5670 delete arg4;
5671 }
5672 {
5673 if (temp5)
5674 delete arg5;
5675 }
5676 return NULL;
5677 }
5678
5679
5680 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5681 PyObject *resultobj = 0;
5682 wxString *arg1 = 0 ;
5683 wxString *arg2 = 0 ;
5684 wxString const &arg3_defvalue = wxPyEmptyString ;
5685 wxString *arg3 = (wxString *) &arg3_defvalue ;
5686 wxWindow *arg4 = (wxWindow *) NULL ;
5687 wxString result;
5688 bool temp1 = false ;
5689 bool temp2 = false ;
5690 bool temp3 = false ;
5691 void *argp4 = 0 ;
5692 int res4 = 0 ;
5693 PyObject * obj0 = 0 ;
5694 PyObject * obj1 = 0 ;
5695 PyObject * obj2 = 0 ;
5696 PyObject * obj3 = 0 ;
5697 char * kwnames[] = {
5698 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5699 };
5700
5701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5702 {
5703 arg1 = wxString_in_helper(obj0);
5704 if (arg1 == NULL) SWIG_fail;
5705 temp1 = true;
5706 }
5707 {
5708 arg2 = wxString_in_helper(obj1);
5709 if (arg2 == NULL) SWIG_fail;
5710 temp2 = true;
5711 }
5712 if (obj2) {
5713 {
5714 arg3 = wxString_in_helper(obj2);
5715 if (arg3 == NULL) SWIG_fail;
5716 temp3 = true;
5717 }
5718 }
5719 if (obj3) {
5720 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5721 if (!SWIG_IsOK(res4)) {
5722 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5723 }
5724 arg4 = reinterpret_cast< wxWindow * >(argp4);
5725 }
5726 {
5727 if (!wxPyCheckForApp()) SWIG_fail;
5728 PyThreadState* __tstate = wxPyBeginAllowThreads();
5729 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5730 wxPyEndAllowThreads(__tstate);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 {
5734 #if wxUSE_UNICODE
5735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5736 #else
5737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5738 #endif
5739 }
5740 {
5741 if (temp1)
5742 delete arg1;
5743 }
5744 {
5745 if (temp2)
5746 delete arg2;
5747 }
5748 {
5749 if (temp3)
5750 delete arg3;
5751 }
5752 return resultobj;
5753 fail:
5754 {
5755 if (temp1)
5756 delete arg1;
5757 }
5758 {
5759 if (temp2)
5760 delete arg2;
5761 }
5762 {
5763 if (temp3)
5764 delete arg3;
5765 }
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5771 PyObject *resultobj = 0;
5772 wxString *arg1 = 0 ;
5773 wxString *arg2 = 0 ;
5774 wxString const &arg3_defvalue = wxPyEmptyString ;
5775 wxString *arg3 = (wxString *) &arg3_defvalue ;
5776 wxWindow *arg4 = (wxWindow *) NULL ;
5777 wxString result;
5778 bool temp1 = false ;
5779 bool temp2 = false ;
5780 bool temp3 = false ;
5781 void *argp4 = 0 ;
5782 int res4 = 0 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 PyObject * obj2 = 0 ;
5786 PyObject * obj3 = 0 ;
5787 char * kwnames[] = {
5788 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5789 };
5790
5791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5792 {
5793 arg1 = wxString_in_helper(obj0);
5794 if (arg1 == NULL) SWIG_fail;
5795 temp1 = true;
5796 }
5797 {
5798 arg2 = wxString_in_helper(obj1);
5799 if (arg2 == NULL) SWIG_fail;
5800 temp2 = true;
5801 }
5802 if (obj2) {
5803 {
5804 arg3 = wxString_in_helper(obj2);
5805 if (arg3 == NULL) SWIG_fail;
5806 temp3 = true;
5807 }
5808 }
5809 if (obj3) {
5810 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5811 if (!SWIG_IsOK(res4)) {
5812 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5813 }
5814 arg4 = reinterpret_cast< wxWindow * >(argp4);
5815 }
5816 {
5817 if (!wxPyCheckForApp()) SWIG_fail;
5818 PyThreadState* __tstate = wxPyBeginAllowThreads();
5819 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5820 wxPyEndAllowThreads(__tstate);
5821 if (PyErr_Occurred()) SWIG_fail;
5822 }
5823 {
5824 #if wxUSE_UNICODE
5825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5826 #else
5827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5828 #endif
5829 }
5830 {
5831 if (temp1)
5832 delete arg1;
5833 }
5834 {
5835 if (temp2)
5836 delete arg2;
5837 }
5838 {
5839 if (temp3)
5840 delete arg3;
5841 }
5842 return resultobj;
5843 fail:
5844 {
5845 if (temp1)
5846 delete arg1;
5847 }
5848 {
5849 if (temp2)
5850 delete arg2;
5851 }
5852 {
5853 if (temp3)
5854 delete arg3;
5855 }
5856 return NULL;
5857 }
5858
5859
5860 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5861 PyObject *resultobj = 0;
5862 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5863 wxString *arg1 = (wxString *) &arg1_defvalue ;
5864 wxString const &arg2_defvalue = wxPyEmptyString ;
5865 wxString *arg2 = (wxString *) &arg2_defvalue ;
5866 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5867 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5868 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5869 wxWindow *arg5 = (wxWindow *) NULL ;
5870 wxString result;
5871 bool temp1 = false ;
5872 bool temp2 = false ;
5873 long val3 ;
5874 int ecode3 = 0 ;
5875 wxPoint temp4 ;
5876 void *argp5 = 0 ;
5877 int res5 = 0 ;
5878 PyObject * obj0 = 0 ;
5879 PyObject * obj1 = 0 ;
5880 PyObject * obj2 = 0 ;
5881 PyObject * obj3 = 0 ;
5882 PyObject * obj4 = 0 ;
5883 char * kwnames[] = {
5884 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5885 };
5886
5887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5888 if (obj0) {
5889 {
5890 arg1 = wxString_in_helper(obj0);
5891 if (arg1 == NULL) SWIG_fail;
5892 temp1 = true;
5893 }
5894 }
5895 if (obj1) {
5896 {
5897 arg2 = wxString_in_helper(obj1);
5898 if (arg2 == NULL) SWIG_fail;
5899 temp2 = true;
5900 }
5901 }
5902 if (obj2) {
5903 ecode3 = SWIG_AsVal_long(obj2, &val3);
5904 if (!SWIG_IsOK(ecode3)) {
5905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5906 }
5907 arg3 = static_cast< long >(val3);
5908 }
5909 if (obj3) {
5910 {
5911 arg4 = &temp4;
5912 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5913 }
5914 }
5915 if (obj4) {
5916 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5917 if (!SWIG_IsOK(res5)) {
5918 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5919 }
5920 arg5 = reinterpret_cast< wxWindow * >(argp5);
5921 }
5922 {
5923 if (!wxPyCheckForApp()) SWIG_fail;
5924 PyThreadState* __tstate = wxPyBeginAllowThreads();
5925 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5926 wxPyEndAllowThreads(__tstate);
5927 if (PyErr_Occurred()) SWIG_fail;
5928 }
5929 {
5930 #if wxUSE_UNICODE
5931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5932 #else
5933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5934 #endif
5935 }
5936 {
5937 if (temp1)
5938 delete arg1;
5939 }
5940 {
5941 if (temp2)
5942 delete arg2;
5943 }
5944 return resultobj;
5945 fail:
5946 {
5947 if (temp1)
5948 delete arg1;
5949 }
5950 {
5951 if (temp2)
5952 delete arg2;
5953 }
5954 return NULL;
5955 }
5956
5957
5958 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5959 PyObject *resultobj = 0;
5960 wxString *arg1 = 0 ;
5961 wxString const &arg2_defvalue = wxPyEmptyString ;
5962 wxString *arg2 = (wxString *) &arg2_defvalue ;
5963 wxString const &arg3_defvalue = wxPyEmptyString ;
5964 wxString *arg3 = (wxString *) &arg3_defvalue ;
5965 wxWindow *arg4 = (wxWindow *) NULL ;
5966 int arg5 = (int) -1 ;
5967 int arg6 = (int) -1 ;
5968 bool arg7 = (bool) true ;
5969 wxString result;
5970 bool temp1 = false ;
5971 bool temp2 = false ;
5972 bool temp3 = false ;
5973 void *argp4 = 0 ;
5974 int res4 = 0 ;
5975 int val5 ;
5976 int ecode5 = 0 ;
5977 int val6 ;
5978 int ecode6 = 0 ;
5979 bool val7 ;
5980 int ecode7 = 0 ;
5981 PyObject * obj0 = 0 ;
5982 PyObject * obj1 = 0 ;
5983 PyObject * obj2 = 0 ;
5984 PyObject * obj3 = 0 ;
5985 PyObject * obj4 = 0 ;
5986 PyObject * obj5 = 0 ;
5987 PyObject * obj6 = 0 ;
5988 char * kwnames[] = {
5989 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5990 };
5991
5992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5993 {
5994 arg1 = wxString_in_helper(obj0);
5995 if (arg1 == NULL) SWIG_fail;
5996 temp1 = true;
5997 }
5998 if (obj1) {
5999 {
6000 arg2 = wxString_in_helper(obj1);
6001 if (arg2 == NULL) SWIG_fail;
6002 temp2 = true;
6003 }
6004 }
6005 if (obj2) {
6006 {
6007 arg3 = wxString_in_helper(obj2);
6008 if (arg3 == NULL) SWIG_fail;
6009 temp3 = true;
6010 }
6011 }
6012 if (obj3) {
6013 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6014 if (!SWIG_IsOK(res4)) {
6015 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6016 }
6017 arg4 = reinterpret_cast< wxWindow * >(argp4);
6018 }
6019 if (obj4) {
6020 ecode5 = SWIG_AsVal_int(obj4, &val5);
6021 if (!SWIG_IsOK(ecode5)) {
6022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6023 }
6024 arg5 = static_cast< int >(val5);
6025 }
6026 if (obj5) {
6027 ecode6 = SWIG_AsVal_int(obj5, &val6);
6028 if (!SWIG_IsOK(ecode6)) {
6029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6030 }
6031 arg6 = static_cast< int >(val6);
6032 }
6033 if (obj6) {
6034 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6035 if (!SWIG_IsOK(ecode7)) {
6036 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6037 }
6038 arg7 = static_cast< bool >(val7);
6039 }
6040 {
6041 if (!wxPyCheckForApp()) SWIG_fail;
6042 PyThreadState* __tstate = wxPyBeginAllowThreads();
6043 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6044 wxPyEndAllowThreads(__tstate);
6045 if (PyErr_Occurred()) SWIG_fail;
6046 }
6047 {
6048 #if wxUSE_UNICODE
6049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6050 #else
6051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6052 #endif
6053 }
6054 {
6055 if (temp1)
6056 delete arg1;
6057 }
6058 {
6059 if (temp2)
6060 delete arg2;
6061 }
6062 {
6063 if (temp3)
6064 delete arg3;
6065 }
6066 return resultobj;
6067 fail:
6068 {
6069 if (temp1)
6070 delete arg1;
6071 }
6072 {
6073 if (temp2)
6074 delete arg2;
6075 }
6076 {
6077 if (temp3)
6078 delete arg3;
6079 }
6080 return NULL;
6081 }
6082
6083
6084 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj = 0;
6086 wxString *arg1 = 0 ;
6087 wxString const &arg2_defvalue = wxPyEmptyString ;
6088 wxString *arg2 = (wxString *) &arg2_defvalue ;
6089 wxString const &arg3_defvalue = wxPyEmptyString ;
6090 wxString *arg3 = (wxString *) &arg3_defvalue ;
6091 wxWindow *arg4 = (wxWindow *) NULL ;
6092 wxString result;
6093 bool temp1 = false ;
6094 bool temp2 = false ;
6095 bool temp3 = false ;
6096 void *argp4 = 0 ;
6097 int res4 = 0 ;
6098 PyObject * obj0 = 0 ;
6099 PyObject * obj1 = 0 ;
6100 PyObject * obj2 = 0 ;
6101 PyObject * obj3 = 0 ;
6102 char * kwnames[] = {
6103 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6104 };
6105
6106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6107 {
6108 arg1 = wxString_in_helper(obj0);
6109 if (arg1 == NULL) SWIG_fail;
6110 temp1 = true;
6111 }
6112 if (obj1) {
6113 {
6114 arg2 = wxString_in_helper(obj1);
6115 if (arg2 == NULL) SWIG_fail;
6116 temp2 = true;
6117 }
6118 }
6119 if (obj2) {
6120 {
6121 arg3 = wxString_in_helper(obj2);
6122 if (arg3 == NULL) SWIG_fail;
6123 temp3 = true;
6124 }
6125 }
6126 if (obj3) {
6127 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6128 if (!SWIG_IsOK(res4)) {
6129 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6130 }
6131 arg4 = reinterpret_cast< wxWindow * >(argp4);
6132 }
6133 {
6134 if (!wxPyCheckForApp()) SWIG_fail;
6135 PyThreadState* __tstate = wxPyBeginAllowThreads();
6136 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6137 wxPyEndAllowThreads(__tstate);
6138 if (PyErr_Occurred()) SWIG_fail;
6139 }
6140 {
6141 #if wxUSE_UNICODE
6142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6143 #else
6144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6145 #endif
6146 }
6147 {
6148 if (temp1)
6149 delete arg1;
6150 }
6151 {
6152 if (temp2)
6153 delete arg2;
6154 }
6155 {
6156 if (temp3)
6157 delete arg3;
6158 }
6159 return resultobj;
6160 fail:
6161 {
6162 if (temp1)
6163 delete arg1;
6164 }
6165 {
6166 if (temp2)
6167 delete arg2;
6168 }
6169 {
6170 if (temp3)
6171 delete arg3;
6172 }
6173 return NULL;
6174 }
6175
6176
6177 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6178 PyObject *resultobj = 0;
6179 wxString *arg1 = 0 ;
6180 wxString *arg2 = 0 ;
6181 int arg3 ;
6182 wxString *arg4 = (wxString *) 0 ;
6183 wxWindow *arg5 = (wxWindow *) NULL ;
6184 int arg6 = (int) -1 ;
6185 int arg7 = (int) -1 ;
6186 bool arg8 = (bool) true ;
6187 int arg9 = (int) 150 ;
6188 int arg10 = (int) 200 ;
6189 wxString result;
6190 bool temp1 = false ;
6191 bool temp2 = false ;
6192 void *argp5 = 0 ;
6193 int res5 = 0 ;
6194 int val6 ;
6195 int ecode6 = 0 ;
6196 int val7 ;
6197 int ecode7 = 0 ;
6198 bool val8 ;
6199 int ecode8 = 0 ;
6200 int val9 ;
6201 int ecode9 = 0 ;
6202 int val10 ;
6203 int ecode10 = 0 ;
6204 PyObject * obj0 = 0 ;
6205 PyObject * obj1 = 0 ;
6206 PyObject * obj2 = 0 ;
6207 PyObject * obj3 = 0 ;
6208 PyObject * obj4 = 0 ;
6209 PyObject * obj5 = 0 ;
6210 PyObject * obj6 = 0 ;
6211 PyObject * obj7 = 0 ;
6212 PyObject * obj8 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6218 {
6219 arg1 = wxString_in_helper(obj0);
6220 if (arg1 == NULL) SWIG_fail;
6221 temp1 = true;
6222 }
6223 {
6224 arg2 = wxString_in_helper(obj1);
6225 if (arg2 == NULL) SWIG_fail;
6226 temp2 = true;
6227 }
6228 {
6229 arg3 = PyList_Size(obj2);
6230 arg4 = wxString_LIST_helper(obj2);
6231 if (arg4 == NULL) SWIG_fail;
6232 }
6233 if (obj3) {
6234 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6235 if (!SWIG_IsOK(res5)) {
6236 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6237 }
6238 arg5 = reinterpret_cast< wxWindow * >(argp5);
6239 }
6240 if (obj4) {
6241 ecode6 = SWIG_AsVal_int(obj4, &val6);
6242 if (!SWIG_IsOK(ecode6)) {
6243 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6244 }
6245 arg6 = static_cast< int >(val6);
6246 }
6247 if (obj5) {
6248 ecode7 = SWIG_AsVal_int(obj5, &val7);
6249 if (!SWIG_IsOK(ecode7)) {
6250 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6251 }
6252 arg7 = static_cast< int >(val7);
6253 }
6254 if (obj6) {
6255 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6256 if (!SWIG_IsOK(ecode8)) {
6257 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6258 }
6259 arg8 = static_cast< bool >(val8);
6260 }
6261 if (obj7) {
6262 ecode9 = SWIG_AsVal_int(obj7, &val9);
6263 if (!SWIG_IsOK(ecode9)) {
6264 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6265 }
6266 arg9 = static_cast< int >(val9);
6267 }
6268 if (obj8) {
6269 ecode10 = SWIG_AsVal_int(obj8, &val10);
6270 if (!SWIG_IsOK(ecode10)) {
6271 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6272 }
6273 arg10 = static_cast< int >(val10);
6274 }
6275 {
6276 if (!wxPyCheckForApp()) SWIG_fail;
6277 PyThreadState* __tstate = wxPyBeginAllowThreads();
6278 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6279 wxPyEndAllowThreads(__tstate);
6280 if (PyErr_Occurred()) SWIG_fail;
6281 }
6282 {
6283 #if wxUSE_UNICODE
6284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6285 #else
6286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6287 #endif
6288 }
6289 {
6290 if (temp1)
6291 delete arg1;
6292 }
6293 {
6294 if (temp2)
6295 delete arg2;
6296 }
6297 {
6298 if (arg4) delete [] arg4;
6299 }
6300 return resultobj;
6301 fail:
6302 {
6303 if (temp1)
6304 delete arg1;
6305 }
6306 {
6307 if (temp2)
6308 delete arg2;
6309 }
6310 {
6311 if (arg4) delete [] arg4;
6312 }
6313 return NULL;
6314 }
6315
6316
6317 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj = 0;
6319 wxString *arg1 = 0 ;
6320 wxString *arg2 = 0 ;
6321 int arg3 ;
6322 wxString *arg4 = (wxString *) 0 ;
6323 wxWindow *arg5 = (wxWindow *) NULL ;
6324 int arg6 = (int) -1 ;
6325 int arg7 = (int) -1 ;
6326 bool arg8 = (bool) true ;
6327 int arg9 = (int) 150 ;
6328 int arg10 = (int) 200 ;
6329 int result;
6330 bool temp1 = false ;
6331 bool temp2 = false ;
6332 void *argp5 = 0 ;
6333 int res5 = 0 ;
6334 int val6 ;
6335 int ecode6 = 0 ;
6336 int val7 ;
6337 int ecode7 = 0 ;
6338 bool val8 ;
6339 int ecode8 = 0 ;
6340 int val9 ;
6341 int ecode9 = 0 ;
6342 int val10 ;
6343 int ecode10 = 0 ;
6344 PyObject * obj0 = 0 ;
6345 PyObject * obj1 = 0 ;
6346 PyObject * obj2 = 0 ;
6347 PyObject * obj3 = 0 ;
6348 PyObject * obj4 = 0 ;
6349 PyObject * obj5 = 0 ;
6350 PyObject * obj6 = 0 ;
6351 PyObject * obj7 = 0 ;
6352 PyObject * obj8 = 0 ;
6353 char * kwnames[] = {
6354 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6355 };
6356
6357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6358 {
6359 arg1 = wxString_in_helper(obj0);
6360 if (arg1 == NULL) SWIG_fail;
6361 temp1 = true;
6362 }
6363 {
6364 arg2 = wxString_in_helper(obj1);
6365 if (arg2 == NULL) SWIG_fail;
6366 temp2 = true;
6367 }
6368 {
6369 arg3 = PyList_Size(obj2);
6370 arg4 = wxString_LIST_helper(obj2);
6371 if (arg4 == NULL) SWIG_fail;
6372 }
6373 if (obj3) {
6374 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6375 if (!SWIG_IsOK(res5)) {
6376 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6377 }
6378 arg5 = reinterpret_cast< wxWindow * >(argp5);
6379 }
6380 if (obj4) {
6381 ecode6 = SWIG_AsVal_int(obj4, &val6);
6382 if (!SWIG_IsOK(ecode6)) {
6383 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6384 }
6385 arg6 = static_cast< int >(val6);
6386 }
6387 if (obj5) {
6388 ecode7 = SWIG_AsVal_int(obj5, &val7);
6389 if (!SWIG_IsOK(ecode7)) {
6390 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6391 }
6392 arg7 = static_cast< int >(val7);
6393 }
6394 if (obj6) {
6395 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6396 if (!SWIG_IsOK(ecode8)) {
6397 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6398 }
6399 arg8 = static_cast< bool >(val8);
6400 }
6401 if (obj7) {
6402 ecode9 = SWIG_AsVal_int(obj7, &val9);
6403 if (!SWIG_IsOK(ecode9)) {
6404 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6405 }
6406 arg9 = static_cast< int >(val9);
6407 }
6408 if (obj8) {
6409 ecode10 = SWIG_AsVal_int(obj8, &val10);
6410 if (!SWIG_IsOK(ecode10)) {
6411 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6412 }
6413 arg10 = static_cast< int >(val10);
6414 }
6415 {
6416 if (!wxPyCheckForApp()) SWIG_fail;
6417 PyThreadState* __tstate = wxPyBeginAllowThreads();
6418 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6419 wxPyEndAllowThreads(__tstate);
6420 if (PyErr_Occurred()) SWIG_fail;
6421 }
6422 resultobj = SWIG_From_int(static_cast< int >(result));
6423 {
6424 if (temp1)
6425 delete arg1;
6426 }
6427 {
6428 if (temp2)
6429 delete arg2;
6430 }
6431 {
6432 if (arg4) delete [] arg4;
6433 }
6434 return resultobj;
6435 fail:
6436 {
6437 if (temp1)
6438 delete arg1;
6439 }
6440 {
6441 if (temp2)
6442 delete arg2;
6443 }
6444 {
6445 if (arg4) delete [] arg4;
6446 }
6447 return NULL;
6448 }
6449
6450
6451 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6452 PyObject *resultobj = 0;
6453 wxString *arg1 = 0 ;
6454 wxString const &arg2_defvalue = wxPyEmptyString ;
6455 wxString *arg2 = (wxString *) &arg2_defvalue ;
6456 int arg3 = (int) wxOK|wxCENTRE ;
6457 wxWindow *arg4 = (wxWindow *) NULL ;
6458 int arg5 = (int) -1 ;
6459 int arg6 = (int) -1 ;
6460 int result;
6461 bool temp1 = false ;
6462 bool temp2 = false ;
6463 int val3 ;
6464 int ecode3 = 0 ;
6465 void *argp4 = 0 ;
6466 int res4 = 0 ;
6467 int val5 ;
6468 int ecode5 = 0 ;
6469 int val6 ;
6470 int ecode6 = 0 ;
6471 PyObject * obj0 = 0 ;
6472 PyObject * obj1 = 0 ;
6473 PyObject * obj2 = 0 ;
6474 PyObject * obj3 = 0 ;
6475 PyObject * obj4 = 0 ;
6476 PyObject * obj5 = 0 ;
6477 char * kwnames[] = {
6478 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6479 };
6480
6481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6482 {
6483 arg1 = wxString_in_helper(obj0);
6484 if (arg1 == NULL) SWIG_fail;
6485 temp1 = true;
6486 }
6487 if (obj1) {
6488 {
6489 arg2 = wxString_in_helper(obj1);
6490 if (arg2 == NULL) SWIG_fail;
6491 temp2 = true;
6492 }
6493 }
6494 if (obj2) {
6495 ecode3 = SWIG_AsVal_int(obj2, &val3);
6496 if (!SWIG_IsOK(ecode3)) {
6497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6498 }
6499 arg3 = static_cast< int >(val3);
6500 }
6501 if (obj3) {
6502 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6503 if (!SWIG_IsOK(res4)) {
6504 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6505 }
6506 arg4 = reinterpret_cast< wxWindow * >(argp4);
6507 }
6508 if (obj4) {
6509 ecode5 = SWIG_AsVal_int(obj4, &val5);
6510 if (!SWIG_IsOK(ecode5)) {
6511 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6512 }
6513 arg5 = static_cast< int >(val5);
6514 }
6515 if (obj5) {
6516 ecode6 = SWIG_AsVal_int(obj5, &val6);
6517 if (!SWIG_IsOK(ecode6)) {
6518 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6519 }
6520 arg6 = static_cast< int >(val6);
6521 }
6522 {
6523 if (!wxPyCheckForApp()) SWIG_fail;
6524 PyThreadState* __tstate = wxPyBeginAllowThreads();
6525 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6526 wxPyEndAllowThreads(__tstate);
6527 if (PyErr_Occurred()) SWIG_fail;
6528 }
6529 resultobj = SWIG_From_int(static_cast< int >(result));
6530 {
6531 if (temp1)
6532 delete arg1;
6533 }
6534 {
6535 if (temp2)
6536 delete arg2;
6537 }
6538 return resultobj;
6539 fail:
6540 {
6541 if (temp1)
6542 delete arg1;
6543 }
6544 {
6545 if (temp2)
6546 delete arg2;
6547 }
6548 return NULL;
6549 }
6550
6551
6552 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6553 PyObject *resultobj = 0;
6554 bool result;
6555
6556 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6557 {
6558 if (!wxPyCheckForApp()) SWIG_fail;
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 result = (bool)wxColourDisplay();
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 {
6565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6566 }
6567 return resultobj;
6568 fail:
6569 return NULL;
6570 }
6571
6572
6573 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6574 PyObject *resultobj = 0;
6575 int result;
6576
6577 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6578 {
6579 if (!wxPyCheckForApp()) SWIG_fail;
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 result = (int)wxDisplayDepth();
6582 wxPyEndAllowThreads(__tstate);
6583 if (PyErr_Occurred()) SWIG_fail;
6584 }
6585 resultobj = SWIG_From_int(static_cast< int >(result));
6586 return resultobj;
6587 fail:
6588 return NULL;
6589 }
6590
6591
6592 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6593 PyObject *resultobj = 0;
6594 int result;
6595
6596 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6597 {
6598 if (!wxPyCheckForApp()) SWIG_fail;
6599 PyThreadState* __tstate = wxPyBeginAllowThreads();
6600 result = (int)wxGetDisplayDepth();
6601 wxPyEndAllowThreads(__tstate);
6602 if (PyErr_Occurred()) SWIG_fail;
6603 }
6604 resultobj = SWIG_From_int(static_cast< int >(result));
6605 return resultobj;
6606 fail:
6607 return NULL;
6608 }
6609
6610
6611 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6612 PyObject *resultobj = 0;
6613 int *arg1 = (int *) 0 ;
6614 int *arg2 = (int *) 0 ;
6615 int temp1 ;
6616 int res1 = SWIG_TMPOBJ ;
6617 int temp2 ;
6618 int res2 = SWIG_TMPOBJ ;
6619
6620 arg1 = &temp1;
6621 arg2 = &temp2;
6622 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6623 {
6624 if (!wxPyCheckForApp()) SWIG_fail;
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 wxDisplaySize(arg1,arg2);
6627 wxPyEndAllowThreads(__tstate);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 resultobj = SWIG_Py_Void();
6631 if (SWIG_IsTmpObj(res1)) {
6632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6633 } else {
6634 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6636 }
6637 if (SWIG_IsTmpObj(res2)) {
6638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6639 } else {
6640 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6642 }
6643 return resultobj;
6644 fail:
6645 return NULL;
6646 }
6647
6648
6649 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6650 PyObject *resultobj = 0;
6651 wxSize result;
6652
6653 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6654 {
6655 if (!wxPyCheckForApp()) SWIG_fail;
6656 PyThreadState* __tstate = wxPyBeginAllowThreads();
6657 result = wxGetDisplaySize();
6658 wxPyEndAllowThreads(__tstate);
6659 if (PyErr_Occurred()) SWIG_fail;
6660 }
6661 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6662 return resultobj;
6663 fail:
6664 return NULL;
6665 }
6666
6667
6668 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6669 PyObject *resultobj = 0;
6670 int *arg1 = (int *) 0 ;
6671 int *arg2 = (int *) 0 ;
6672 int temp1 ;
6673 int res1 = SWIG_TMPOBJ ;
6674 int temp2 ;
6675 int res2 = SWIG_TMPOBJ ;
6676
6677 arg1 = &temp1;
6678 arg2 = &temp2;
6679 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6680 {
6681 if (!wxPyCheckForApp()) SWIG_fail;
6682 PyThreadState* __tstate = wxPyBeginAllowThreads();
6683 wxDisplaySizeMM(arg1,arg2);
6684 wxPyEndAllowThreads(__tstate);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 resultobj = SWIG_Py_Void();
6688 if (SWIG_IsTmpObj(res1)) {
6689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6690 } else {
6691 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6692 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6693 }
6694 if (SWIG_IsTmpObj(res2)) {
6695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6696 } else {
6697 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6699 }
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6707 PyObject *resultobj = 0;
6708 wxSize result;
6709
6710 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6711 {
6712 if (!wxPyCheckForApp()) SWIG_fail;
6713 PyThreadState* __tstate = wxPyBeginAllowThreads();
6714 result = wxGetDisplaySizeMM();
6715 wxPyEndAllowThreads(__tstate);
6716 if (PyErr_Occurred()) SWIG_fail;
6717 }
6718 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6719 return resultobj;
6720 fail:
6721 return NULL;
6722 }
6723
6724
6725 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6726 PyObject *resultobj = 0;
6727 int *arg1 = (int *) 0 ;
6728 int *arg2 = (int *) 0 ;
6729 int *arg3 = (int *) 0 ;
6730 int *arg4 = (int *) 0 ;
6731 int temp1 ;
6732 int res1 = SWIG_TMPOBJ ;
6733 int temp2 ;
6734 int res2 = SWIG_TMPOBJ ;
6735 int temp3 ;
6736 int res3 = SWIG_TMPOBJ ;
6737 int temp4 ;
6738 int res4 = SWIG_TMPOBJ ;
6739
6740 arg1 = &temp1;
6741 arg2 = &temp2;
6742 arg3 = &temp3;
6743 arg4 = &temp4;
6744 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6745 {
6746 if (!wxPyCheckForApp()) SWIG_fail;
6747 PyThreadState* __tstate = wxPyBeginAllowThreads();
6748 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6749 wxPyEndAllowThreads(__tstate);
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 resultobj = SWIG_Py_Void();
6753 if (SWIG_IsTmpObj(res1)) {
6754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6755 } else {
6756 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6758 }
6759 if (SWIG_IsTmpObj(res2)) {
6760 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6761 } else {
6762 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6763 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6764 }
6765 if (SWIG_IsTmpObj(res3)) {
6766 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6767 } else {
6768 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6770 }
6771 if (SWIG_IsTmpObj(res4)) {
6772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6773 } else {
6774 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6784 PyObject *resultobj = 0;
6785 wxRect result;
6786
6787 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6788 {
6789 if (!wxPyCheckForApp()) SWIG_fail;
6790 PyThreadState* __tstate = wxPyBeginAllowThreads();
6791 result = wxGetClientDisplayRect();
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6796 return resultobj;
6797 fail:
6798 return NULL;
6799 }
6800
6801
6802 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6803 PyObject *resultobj = 0;
6804 wxCursor *arg1 = 0 ;
6805 void *argp1 = 0 ;
6806 int res1 = 0 ;
6807 PyObject * obj0 = 0 ;
6808 char * kwnames[] = {
6809 (char *) "cursor", NULL
6810 };
6811
6812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6813 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6814 if (!SWIG_IsOK(res1)) {
6815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6816 }
6817 if (!argp1) {
6818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6819 }
6820 arg1 = reinterpret_cast< wxCursor * >(argp1);
6821 {
6822 if (!wxPyCheckForApp()) SWIG_fail;
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 wxSetCursor(*arg1);
6825 wxPyEndAllowThreads(__tstate);
6826 if (PyErr_Occurred()) SWIG_fail;
6827 }
6828 resultobj = SWIG_Py_Void();
6829 return resultobj;
6830 fail:
6831 return NULL;
6832 }
6833
6834
6835 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6836 PyObject *resultobj = 0;
6837 void *result = 0 ;
6838
6839 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6840 {
6841 if (!wxPyCheckForApp()) SWIG_fail;
6842 PyThreadState* __tstate = wxPyBeginAllowThreads();
6843 result = (void *)wxGetXDisplay();
6844 wxPyEndAllowThreads(__tstate);
6845 if (PyErr_Occurred()) SWIG_fail;
6846 }
6847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6848 return resultobj;
6849 fail:
6850 return NULL;
6851 }
6852
6853
6854 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj = 0;
6856 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6857 void *argp1 = 0 ;
6858 int res1 = 0 ;
6859 PyObject * obj0 = 0 ;
6860 char * kwnames[] = {
6861 (char *) "cursor", NULL
6862 };
6863
6864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6865 if (obj0) {
6866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6867 if (!SWIG_IsOK(res1)) {
6868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6869 }
6870 arg1 = reinterpret_cast< wxCursor * >(argp1);
6871 }
6872 {
6873 if (!wxPyCheckForApp()) SWIG_fail;
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 wxBeginBusyCursor(arg1);
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 resultobj = SWIG_Py_Void();
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6887 PyObject *resultobj = 0;
6888 wxPoint result;
6889
6890 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6891 {
6892 if (!wxPyCheckForApp()) SWIG_fail;
6893 PyThreadState* __tstate = wxPyBeginAllowThreads();
6894 result = wxGetMousePosition();
6895 wxPyEndAllowThreads(__tstate);
6896 if (PyErr_Occurred()) SWIG_fail;
6897 }
6898 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6899 return resultobj;
6900 fail:
6901 return NULL;
6902 }
6903
6904
6905 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6906 PyObject *resultobj = 0;
6907 wxWindow *result = 0 ;
6908
6909 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6910 {
6911 if (!wxPyCheckForApp()) SWIG_fail;
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = (wxWindow *)FindWindowAtPointer();
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 {
6918 resultobj = wxPyMake_wxObject(result, 0);
6919 }
6920 return resultobj;
6921 fail:
6922 return NULL;
6923 }
6924
6925
6926 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6927 PyObject *resultobj = 0;
6928 wxWindow *result = 0 ;
6929
6930 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6931 {
6932 if (!wxPyCheckForApp()) SWIG_fail;
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 result = (wxWindow *)wxGetActiveWindow();
6935 wxPyEndAllowThreads(__tstate);
6936 if (PyErr_Occurred()) SWIG_fail;
6937 }
6938 {
6939 resultobj = wxPyMake_wxObject(result, 0);
6940 }
6941 return resultobj;
6942 fail:
6943 return NULL;
6944 }
6945
6946
6947 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6948 PyObject *resultobj = 0;
6949 wxPoint *arg1 = 0 ;
6950 wxWindow *result = 0 ;
6951 wxPoint temp1 ;
6952 PyObject * obj0 = 0 ;
6953 char * kwnames[] = {
6954 (char *) "pt", NULL
6955 };
6956
6957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6958 {
6959 arg1 = &temp1;
6960 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6961 }
6962 {
6963 if (!wxPyCheckForApp()) SWIG_fail;
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6966 wxPyEndAllowThreads(__tstate);
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 {
6970 resultobj = wxPyMake_wxObject(result, 0);
6971 }
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6979 PyObject *resultobj = 0;
6980 wxPoint *arg1 = 0 ;
6981 wxWindow *result = 0 ;
6982 wxPoint temp1 ;
6983 PyObject * obj0 = 0 ;
6984 char * kwnames[] = {
6985 (char *) "pt", NULL
6986 };
6987
6988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6989 {
6990 arg1 = &temp1;
6991 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6992 }
6993 {
6994 if (!wxPyCheckForApp()) SWIG_fail;
6995 PyThreadState* __tstate = wxPyBeginAllowThreads();
6996 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6997 wxPyEndAllowThreads(__tstate);
6998 if (PyErr_Occurred()) SWIG_fail;
6999 }
7000 {
7001 resultobj = wxPyMake_wxObject(result, 0);
7002 }
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7010 PyObject *resultobj = 0;
7011 wxWindow *arg1 = (wxWindow *) 0 ;
7012 wxWindow *result = 0 ;
7013 void *argp1 = 0 ;
7014 int res1 = 0 ;
7015 PyObject * obj0 = 0 ;
7016 char * kwnames[] = {
7017 (char *) "win", NULL
7018 };
7019
7020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7022 if (!SWIG_IsOK(res1)) {
7023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7024 }
7025 arg1 = reinterpret_cast< wxWindow * >(argp1);
7026 {
7027 if (!wxPyCheckForApp()) SWIG_fail;
7028 PyThreadState* __tstate = wxPyBeginAllowThreads();
7029 result = (wxWindow *)wxGetTopLevelParent(arg1);
7030 wxPyEndAllowThreads(__tstate);
7031 if (PyErr_Occurred()) SWIG_fail;
7032 }
7033 {
7034 resultobj = wxPyMake_wxObject(result, 0);
7035 }
7036 return resultobj;
7037 fail:
7038 return NULL;
7039 }
7040
7041
7042 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7043 PyObject *resultobj = 0;
7044 wxString *arg1 = 0 ;
7045 bool result;
7046 bool temp1 = false ;
7047 PyObject * obj0 = 0 ;
7048 char * kwnames[] = {
7049 (char *) "url", NULL
7050 };
7051
7052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7053 {
7054 arg1 = wxString_in_helper(obj0);
7055 if (arg1 == NULL) SWIG_fail;
7056 temp1 = true;
7057 }
7058 {
7059 PyThreadState* __tstate = wxPyBeginAllowThreads();
7060 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7061 wxPyEndAllowThreads(__tstate);
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 {
7065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7066 }
7067 {
7068 if (temp1)
7069 delete arg1;
7070 }
7071 return resultobj;
7072 fail:
7073 {
7074 if (temp1)
7075 delete arg1;
7076 }
7077 return NULL;
7078 }
7079
7080
7081 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7082 PyObject *resultobj = 0;
7083 wxKeyCode arg1 ;
7084 bool result;
7085 int val1 ;
7086 int ecode1 = 0 ;
7087 PyObject * obj0 = 0 ;
7088 char * kwnames[] = {
7089 (char *) "key", NULL
7090 };
7091
7092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7093 ecode1 = SWIG_AsVal_int(obj0, &val1);
7094 if (!SWIG_IsOK(ecode1)) {
7095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7096 }
7097 arg1 = static_cast< wxKeyCode >(val1);
7098 {
7099 if (!wxPyCheckForApp()) SWIG_fail;
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 result = (bool)wxGetKeyState(arg1);
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 {
7106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7107 }
7108 return resultobj;
7109 fail:
7110 return NULL;
7111 }
7112
7113
7114 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7115 PyObject *resultobj = 0;
7116 wxMouseState *result = 0 ;
7117
7118 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7119 {
7120 PyThreadState* __tstate = wxPyBeginAllowThreads();
7121 result = (wxMouseState *)new wxMouseState();
7122 wxPyEndAllowThreads(__tstate);
7123 if (PyErr_Occurred()) SWIG_fail;
7124 }
7125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7126 return resultobj;
7127 fail:
7128 return NULL;
7129 }
7130
7131
7132 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7133 PyObject *resultobj = 0;
7134 wxMouseState *arg1 = (wxMouseState *) 0 ;
7135 void *argp1 = 0 ;
7136 int res1 = 0 ;
7137 PyObject *swig_obj[1] ;
7138
7139 if (!args) SWIG_fail;
7140 swig_obj[0] = args;
7141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7142 if (!SWIG_IsOK(res1)) {
7143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7144 }
7145 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7146 {
7147 PyThreadState* __tstate = wxPyBeginAllowThreads();
7148 delete arg1;
7149
7150 wxPyEndAllowThreads(__tstate);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 resultobj = SWIG_Py_Void();
7154 return resultobj;
7155 fail:
7156 return NULL;
7157 }
7158
7159
7160 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7161 PyObject *resultobj = 0;
7162 wxMouseState *arg1 = (wxMouseState *) 0 ;
7163 int result;
7164 void *argp1 = 0 ;
7165 int res1 = 0 ;
7166 PyObject *swig_obj[1] ;
7167
7168 if (!args) SWIG_fail;
7169 swig_obj[0] = args;
7170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7171 if (!SWIG_IsOK(res1)) {
7172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7173 }
7174 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7175 {
7176 PyThreadState* __tstate = wxPyBeginAllowThreads();
7177 result = (int)(arg1)->GetX();
7178 wxPyEndAllowThreads(__tstate);
7179 if (PyErr_Occurred()) SWIG_fail;
7180 }
7181 resultobj = SWIG_From_int(static_cast< int >(result));
7182 return resultobj;
7183 fail:
7184 return NULL;
7185 }
7186
7187
7188 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7189 PyObject *resultobj = 0;
7190 wxMouseState *arg1 = (wxMouseState *) 0 ;
7191 int result;
7192 void *argp1 = 0 ;
7193 int res1 = 0 ;
7194 PyObject *swig_obj[1] ;
7195
7196 if (!args) SWIG_fail;
7197 swig_obj[0] = args;
7198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7199 if (!SWIG_IsOK(res1)) {
7200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7201 }
7202 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7203 {
7204 PyThreadState* __tstate = wxPyBeginAllowThreads();
7205 result = (int)(arg1)->GetY();
7206 wxPyEndAllowThreads(__tstate);
7207 if (PyErr_Occurred()) SWIG_fail;
7208 }
7209 resultobj = SWIG_From_int(static_cast< int >(result));
7210 return resultobj;
7211 fail:
7212 return NULL;
7213 }
7214
7215
7216 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7217 PyObject *resultobj = 0;
7218 wxMouseState *arg1 = (wxMouseState *) 0 ;
7219 bool result;
7220 void *argp1 = 0 ;
7221 int res1 = 0 ;
7222 PyObject *swig_obj[1] ;
7223
7224 if (!args) SWIG_fail;
7225 swig_obj[0] = args;
7226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7227 if (!SWIG_IsOK(res1)) {
7228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7229 }
7230 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7231 {
7232 PyThreadState* __tstate = wxPyBeginAllowThreads();
7233 result = (bool)(arg1)->LeftDown();
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 {
7238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7239 }
7240 return resultobj;
7241 fail:
7242 return NULL;
7243 }
7244
7245
7246 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7247 PyObject *resultobj = 0;
7248 wxMouseState *arg1 = (wxMouseState *) 0 ;
7249 bool result;
7250 void *argp1 = 0 ;
7251 int res1 = 0 ;
7252 PyObject *swig_obj[1] ;
7253
7254 if (!args) SWIG_fail;
7255 swig_obj[0] = args;
7256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7257 if (!SWIG_IsOK(res1)) {
7258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7259 }
7260 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7261 {
7262 PyThreadState* __tstate = wxPyBeginAllowThreads();
7263 result = (bool)(arg1)->MiddleDown();
7264 wxPyEndAllowThreads(__tstate);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 {
7268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7269 }
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7277 PyObject *resultobj = 0;
7278 wxMouseState *arg1 = (wxMouseState *) 0 ;
7279 bool result;
7280 void *argp1 = 0 ;
7281 int res1 = 0 ;
7282 PyObject *swig_obj[1] ;
7283
7284 if (!args) SWIG_fail;
7285 swig_obj[0] = args;
7286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7287 if (!SWIG_IsOK(res1)) {
7288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7289 }
7290 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7291 {
7292 PyThreadState* __tstate = wxPyBeginAllowThreads();
7293 result = (bool)(arg1)->RightDown();
7294 wxPyEndAllowThreads(__tstate);
7295 if (PyErr_Occurred()) SWIG_fail;
7296 }
7297 {
7298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7299 }
7300 return resultobj;
7301 fail:
7302 return NULL;
7303 }
7304
7305
7306 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7307 PyObject *resultobj = 0;
7308 wxMouseState *arg1 = (wxMouseState *) 0 ;
7309 bool result;
7310 void *argp1 = 0 ;
7311 int res1 = 0 ;
7312 PyObject *swig_obj[1] ;
7313
7314 if (!args) SWIG_fail;
7315 swig_obj[0] = args;
7316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7317 if (!SWIG_IsOK(res1)) {
7318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7319 }
7320 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7321 {
7322 PyThreadState* __tstate = wxPyBeginAllowThreads();
7323 result = (bool)(arg1)->ControlDown();
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 {
7328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7329 }
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7337 PyObject *resultobj = 0;
7338 wxMouseState *arg1 = (wxMouseState *) 0 ;
7339 bool result;
7340 void *argp1 = 0 ;
7341 int res1 = 0 ;
7342 PyObject *swig_obj[1] ;
7343
7344 if (!args) SWIG_fail;
7345 swig_obj[0] = args;
7346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7349 }
7350 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7351 {
7352 PyThreadState* __tstate = wxPyBeginAllowThreads();
7353 result = (bool)(arg1)->ShiftDown();
7354 wxPyEndAllowThreads(__tstate);
7355 if (PyErr_Occurred()) SWIG_fail;
7356 }
7357 {
7358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7359 }
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7367 PyObject *resultobj = 0;
7368 wxMouseState *arg1 = (wxMouseState *) 0 ;
7369 bool result;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 PyObject *swig_obj[1] ;
7373
7374 if (!args) SWIG_fail;
7375 swig_obj[0] = args;
7376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7377 if (!SWIG_IsOK(res1)) {
7378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7379 }
7380 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7381 {
7382 PyThreadState* __tstate = wxPyBeginAllowThreads();
7383 result = (bool)(arg1)->AltDown();
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 {
7388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7389 }
7390 return resultobj;
7391 fail:
7392 return NULL;
7393 }
7394
7395
7396 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7397 PyObject *resultobj = 0;
7398 wxMouseState *arg1 = (wxMouseState *) 0 ;
7399 bool result;
7400 void *argp1 = 0 ;
7401 int res1 = 0 ;
7402 PyObject *swig_obj[1] ;
7403
7404 if (!args) SWIG_fail;
7405 swig_obj[0] = args;
7406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7407 if (!SWIG_IsOK(res1)) {
7408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7409 }
7410 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 result = (bool)(arg1)->MetaDown();
7414 wxPyEndAllowThreads(__tstate);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 {
7418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7419 }
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7427 PyObject *resultobj = 0;
7428 wxMouseState *arg1 = (wxMouseState *) 0 ;
7429 bool result;
7430 void *argp1 = 0 ;
7431 int res1 = 0 ;
7432 PyObject *swig_obj[1] ;
7433
7434 if (!args) SWIG_fail;
7435 swig_obj[0] = args;
7436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7437 if (!SWIG_IsOK(res1)) {
7438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7439 }
7440 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7441 {
7442 PyThreadState* __tstate = wxPyBeginAllowThreads();
7443 result = (bool)(arg1)->CmdDown();
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 {
7448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7449 }
7450 return resultobj;
7451 fail:
7452 return NULL;
7453 }
7454
7455
7456 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7457 PyObject *resultobj = 0;
7458 wxMouseState *arg1 = (wxMouseState *) 0 ;
7459 int arg2 ;
7460 void *argp1 = 0 ;
7461 int res1 = 0 ;
7462 int val2 ;
7463 int ecode2 = 0 ;
7464 PyObject * obj0 = 0 ;
7465 PyObject * obj1 = 0 ;
7466 char * kwnames[] = {
7467 (char *) "self",(char *) "x", NULL
7468 };
7469
7470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7472 if (!SWIG_IsOK(res1)) {
7473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7474 }
7475 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7476 ecode2 = SWIG_AsVal_int(obj1, &val2);
7477 if (!SWIG_IsOK(ecode2)) {
7478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7479 }
7480 arg2 = static_cast< int >(val2);
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 (arg1)->SetX(arg2);
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 resultobj = SWIG_Py_Void();
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = 0;
7496 wxMouseState *arg1 = (wxMouseState *) 0 ;
7497 int arg2 ;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 int val2 ;
7501 int ecode2 = 0 ;
7502 PyObject * obj0 = 0 ;
7503 PyObject * obj1 = 0 ;
7504 char * kwnames[] = {
7505 (char *) "self",(char *) "y", NULL
7506 };
7507
7508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7510 if (!SWIG_IsOK(res1)) {
7511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7512 }
7513 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7514 ecode2 = SWIG_AsVal_int(obj1, &val2);
7515 if (!SWIG_IsOK(ecode2)) {
7516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7517 }
7518 arg2 = static_cast< int >(val2);
7519 {
7520 PyThreadState* __tstate = wxPyBeginAllowThreads();
7521 (arg1)->SetY(arg2);
7522 wxPyEndAllowThreads(__tstate);
7523 if (PyErr_Occurred()) SWIG_fail;
7524 }
7525 resultobj = SWIG_Py_Void();
7526 return resultobj;
7527 fail:
7528 return NULL;
7529 }
7530
7531
7532 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7533 PyObject *resultobj = 0;
7534 wxMouseState *arg1 = (wxMouseState *) 0 ;
7535 bool arg2 ;
7536 void *argp1 = 0 ;
7537 int res1 = 0 ;
7538 bool val2 ;
7539 int ecode2 = 0 ;
7540 PyObject * obj0 = 0 ;
7541 PyObject * obj1 = 0 ;
7542 char * kwnames[] = {
7543 (char *) "self",(char *) "down", NULL
7544 };
7545
7546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7548 if (!SWIG_IsOK(res1)) {
7549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7550 }
7551 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7552 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7553 if (!SWIG_IsOK(ecode2)) {
7554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7555 }
7556 arg2 = static_cast< bool >(val2);
7557 {
7558 PyThreadState* __tstate = wxPyBeginAllowThreads();
7559 (arg1)->SetLeftDown(arg2);
7560 wxPyEndAllowThreads(__tstate);
7561 if (PyErr_Occurred()) SWIG_fail;
7562 }
7563 resultobj = SWIG_Py_Void();
7564 return resultobj;
7565 fail:
7566 return NULL;
7567 }
7568
7569
7570 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7571 PyObject *resultobj = 0;
7572 wxMouseState *arg1 = (wxMouseState *) 0 ;
7573 bool arg2 ;
7574 void *argp1 = 0 ;
7575 int res1 = 0 ;
7576 bool val2 ;
7577 int ecode2 = 0 ;
7578 PyObject * obj0 = 0 ;
7579 PyObject * obj1 = 0 ;
7580 char * kwnames[] = {
7581 (char *) "self",(char *) "down", NULL
7582 };
7583
7584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7586 if (!SWIG_IsOK(res1)) {
7587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7588 }
7589 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7590 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7591 if (!SWIG_IsOK(ecode2)) {
7592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7593 }
7594 arg2 = static_cast< bool >(val2);
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 (arg1)->SetMiddleDown(arg2);
7598 wxPyEndAllowThreads(__tstate);
7599 if (PyErr_Occurred()) SWIG_fail;
7600 }
7601 resultobj = SWIG_Py_Void();
7602 return resultobj;
7603 fail:
7604 return NULL;
7605 }
7606
7607
7608 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7609 PyObject *resultobj = 0;
7610 wxMouseState *arg1 = (wxMouseState *) 0 ;
7611 bool arg2 ;
7612 void *argp1 = 0 ;
7613 int res1 = 0 ;
7614 bool val2 ;
7615 int ecode2 = 0 ;
7616 PyObject * obj0 = 0 ;
7617 PyObject * obj1 = 0 ;
7618 char * kwnames[] = {
7619 (char *) "self",(char *) "down", NULL
7620 };
7621
7622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7624 if (!SWIG_IsOK(res1)) {
7625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7626 }
7627 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7628 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7629 if (!SWIG_IsOK(ecode2)) {
7630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7631 }
7632 arg2 = static_cast< bool >(val2);
7633 {
7634 PyThreadState* __tstate = wxPyBeginAllowThreads();
7635 (arg1)->SetRightDown(arg2);
7636 wxPyEndAllowThreads(__tstate);
7637 if (PyErr_Occurred()) SWIG_fail;
7638 }
7639 resultobj = SWIG_Py_Void();
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7647 PyObject *resultobj = 0;
7648 wxMouseState *arg1 = (wxMouseState *) 0 ;
7649 bool arg2 ;
7650 void *argp1 = 0 ;
7651 int res1 = 0 ;
7652 bool val2 ;
7653 int ecode2 = 0 ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 char * kwnames[] = {
7657 (char *) "self",(char *) "down", NULL
7658 };
7659
7660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7662 if (!SWIG_IsOK(res1)) {
7663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7664 }
7665 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7666 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7667 if (!SWIG_IsOK(ecode2)) {
7668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7669 }
7670 arg2 = static_cast< bool >(val2);
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 (arg1)->SetControlDown(arg2);
7674 wxPyEndAllowThreads(__tstate);
7675 if (PyErr_Occurred()) SWIG_fail;
7676 }
7677 resultobj = SWIG_Py_Void();
7678 return resultobj;
7679 fail:
7680 return NULL;
7681 }
7682
7683
7684 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7685 PyObject *resultobj = 0;
7686 wxMouseState *arg1 = (wxMouseState *) 0 ;
7687 bool arg2 ;
7688 void *argp1 = 0 ;
7689 int res1 = 0 ;
7690 bool val2 ;
7691 int ecode2 = 0 ;
7692 PyObject * obj0 = 0 ;
7693 PyObject * obj1 = 0 ;
7694 char * kwnames[] = {
7695 (char *) "self",(char *) "down", NULL
7696 };
7697
7698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7700 if (!SWIG_IsOK(res1)) {
7701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7702 }
7703 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7705 if (!SWIG_IsOK(ecode2)) {
7706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7707 }
7708 arg2 = static_cast< bool >(val2);
7709 {
7710 PyThreadState* __tstate = wxPyBeginAllowThreads();
7711 (arg1)->SetShiftDown(arg2);
7712 wxPyEndAllowThreads(__tstate);
7713 if (PyErr_Occurred()) SWIG_fail;
7714 }
7715 resultobj = SWIG_Py_Void();
7716 return resultobj;
7717 fail:
7718 return NULL;
7719 }
7720
7721
7722 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7723 PyObject *resultobj = 0;
7724 wxMouseState *arg1 = (wxMouseState *) 0 ;
7725 bool arg2 ;
7726 void *argp1 = 0 ;
7727 int res1 = 0 ;
7728 bool val2 ;
7729 int ecode2 = 0 ;
7730 PyObject * obj0 = 0 ;
7731 PyObject * obj1 = 0 ;
7732 char * kwnames[] = {
7733 (char *) "self",(char *) "down", NULL
7734 };
7735
7736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7738 if (!SWIG_IsOK(res1)) {
7739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7740 }
7741 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7743 if (!SWIG_IsOK(ecode2)) {
7744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7745 }
7746 arg2 = static_cast< bool >(val2);
7747 {
7748 PyThreadState* __tstate = wxPyBeginAllowThreads();
7749 (arg1)->SetAltDown(arg2);
7750 wxPyEndAllowThreads(__tstate);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 resultobj = SWIG_Py_Void();
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj = 0;
7762 wxMouseState *arg1 = (wxMouseState *) 0 ;
7763 bool arg2 ;
7764 void *argp1 = 0 ;
7765 int res1 = 0 ;
7766 bool val2 ;
7767 int ecode2 = 0 ;
7768 PyObject * obj0 = 0 ;
7769 PyObject * obj1 = 0 ;
7770 char * kwnames[] = {
7771 (char *) "self",(char *) "down", NULL
7772 };
7773
7774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7776 if (!SWIG_IsOK(res1)) {
7777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7778 }
7779 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7781 if (!SWIG_IsOK(ecode2)) {
7782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7783 }
7784 arg2 = static_cast< bool >(val2);
7785 {
7786 PyThreadState* __tstate = wxPyBeginAllowThreads();
7787 (arg1)->SetMetaDown(arg2);
7788 wxPyEndAllowThreads(__tstate);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 resultobj = SWIG_Py_Void();
7792 return resultobj;
7793 fail:
7794 return NULL;
7795 }
7796
7797
7798 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7799 PyObject *obj;
7800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7801 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7802 return SWIG_Py_Void();
7803 }
7804
7805 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7806 return SWIG_Python_InitShadowInstance(args);
7807 }
7808
7809 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7810 PyObject *resultobj = 0;
7811 wxMouseState result;
7812
7813 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7814 {
7815 PyThreadState* __tstate = wxPyBeginAllowThreads();
7816 result = wxGetMouseState();
7817 wxPyEndAllowThreads(__tstate);
7818 if (PyErr_Occurred()) SWIG_fail;
7819 }
7820 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7821 return resultobj;
7822 fail:
7823 return NULL;
7824 }
7825
7826
7827 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7828 PyObject *resultobj = 0;
7829
7830 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7831 {
7832 if (!wxPyCheckForApp()) SWIG_fail;
7833 PyThreadState* __tstate = wxPyBeginAllowThreads();
7834 wxWakeUpMainThread();
7835 wxPyEndAllowThreads(__tstate);
7836 if (PyErr_Occurred()) SWIG_fail;
7837 }
7838 resultobj = SWIG_Py_Void();
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847
7848 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7849 {
7850 if (!wxPyCheckForApp()) SWIG_fail;
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 wxMutexGuiEnter();
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 resultobj = SWIG_Py_Void();
7857 return resultobj;
7858 fail:
7859 return NULL;
7860 }
7861
7862
7863 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7864 PyObject *resultobj = 0;
7865
7866 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7867 {
7868 if (!wxPyCheckForApp()) SWIG_fail;
7869 PyThreadState* __tstate = wxPyBeginAllowThreads();
7870 wxMutexGuiLeave();
7871 wxPyEndAllowThreads(__tstate);
7872 if (PyErr_Occurred()) SWIG_fail;
7873 }
7874 resultobj = SWIG_Py_Void();
7875 return resultobj;
7876 fail:
7877 return NULL;
7878 }
7879
7880
7881 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7882 PyObject *resultobj = 0;
7883 wxMutexGuiLocker *result = 0 ;
7884
7885 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7886 {
7887 if (!wxPyCheckForApp()) SWIG_fail;
7888 PyThreadState* __tstate = wxPyBeginAllowThreads();
7889 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7890 wxPyEndAllowThreads(__tstate);
7891 if (PyErr_Occurred()) SWIG_fail;
7892 }
7893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7901 PyObject *resultobj = 0;
7902 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7903 void *argp1 = 0 ;
7904 int res1 = 0 ;
7905 PyObject *swig_obj[1] ;
7906
7907 if (!args) SWIG_fail;
7908 swig_obj[0] = args;
7909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7910 if (!SWIG_IsOK(res1)) {
7911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7912 }
7913 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7914 {
7915 PyThreadState* __tstate = wxPyBeginAllowThreads();
7916 delete arg1;
7917
7918 wxPyEndAllowThreads(__tstate);
7919 if (PyErr_Occurred()) SWIG_fail;
7920 }
7921 resultobj = SWIG_Py_Void();
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7929 PyObject *obj;
7930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7931 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7932 return SWIG_Py_Void();
7933 }
7934
7935 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7936 return SWIG_Python_InitShadowInstance(args);
7937 }
7938
7939 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7940 PyObject *resultobj = 0;
7941 bool result;
7942
7943 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7944 {
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = (bool)wxThread_IsMain();
7947 wxPyEndAllowThreads(__tstate);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 {
7951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7952 }
7953 return resultobj;
7954 fail:
7955 return NULL;
7956 }
7957
7958
7959 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7960 PyObject *resultobj = 0;
7961 wxString *arg1 = 0 ;
7962 wxToolTip *result = 0 ;
7963 bool temp1 = false ;
7964 PyObject * obj0 = 0 ;
7965 char * kwnames[] = {
7966 (char *) "tip", NULL
7967 };
7968
7969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7970 {
7971 arg1 = wxString_in_helper(obj0);
7972 if (arg1 == NULL) SWIG_fail;
7973 temp1 = true;
7974 }
7975 {
7976 if (!wxPyCheckForApp()) SWIG_fail;
7977 PyThreadState* __tstate = wxPyBeginAllowThreads();
7978 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7979 wxPyEndAllowThreads(__tstate);
7980 if (PyErr_Occurred()) SWIG_fail;
7981 }
7982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7983 {
7984 if (temp1)
7985 delete arg1;
7986 }
7987 return resultobj;
7988 fail:
7989 {
7990 if (temp1)
7991 delete arg1;
7992 }
7993 return NULL;
7994 }
7995
7996
7997 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7998 PyObject *resultobj = 0;
7999 wxToolTip *arg1 = (wxToolTip *) 0 ;
8000 void *argp1 = 0 ;
8001 int res1 = 0 ;
8002 PyObject *swig_obj[1] ;
8003
8004 if (!args) SWIG_fail;
8005 swig_obj[0] = args;
8006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8007 if (!SWIG_IsOK(res1)) {
8008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8009 }
8010 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 delete arg1;
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 resultobj = SWIG_Py_Void();
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8026 PyObject *resultobj = 0;
8027 wxToolTip *arg1 = (wxToolTip *) 0 ;
8028 wxString *arg2 = 0 ;
8029 void *argp1 = 0 ;
8030 int res1 = 0 ;
8031 bool temp2 = false ;
8032 PyObject * obj0 = 0 ;
8033 PyObject * obj1 = 0 ;
8034 char * kwnames[] = {
8035 (char *) "self",(char *) "tip", NULL
8036 };
8037
8038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8040 if (!SWIG_IsOK(res1)) {
8041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8042 }
8043 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8044 {
8045 arg2 = wxString_in_helper(obj1);
8046 if (arg2 == NULL) SWIG_fail;
8047 temp2 = true;
8048 }
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 (arg1)->SetTip((wxString const &)*arg2);
8052 wxPyEndAllowThreads(__tstate);
8053 if (PyErr_Occurred()) SWIG_fail;
8054 }
8055 resultobj = SWIG_Py_Void();
8056 {
8057 if (temp2)
8058 delete arg2;
8059 }
8060 return resultobj;
8061 fail:
8062 {
8063 if (temp2)
8064 delete arg2;
8065 }
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8071 PyObject *resultobj = 0;
8072 wxToolTip *arg1 = (wxToolTip *) 0 ;
8073 wxString result;
8074 void *argp1 = 0 ;
8075 int res1 = 0 ;
8076 PyObject *swig_obj[1] ;
8077
8078 if (!args) SWIG_fail;
8079 swig_obj[0] = args;
8080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8081 if (!SWIG_IsOK(res1)) {
8082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8083 }
8084 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 result = (arg1)->GetTip();
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 {
8092 #if wxUSE_UNICODE
8093 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8094 #else
8095 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8096 #endif
8097 }
8098 return resultobj;
8099 fail:
8100 return NULL;
8101 }
8102
8103
8104 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8105 PyObject *resultobj = 0;
8106 wxToolTip *arg1 = (wxToolTip *) 0 ;
8107 wxWindow *result = 0 ;
8108 void *argp1 = 0 ;
8109 int res1 = 0 ;
8110 PyObject *swig_obj[1] ;
8111
8112 if (!args) SWIG_fail;
8113 swig_obj[0] = args;
8114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8115 if (!SWIG_IsOK(res1)) {
8116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8117 }
8118 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8119 {
8120 PyThreadState* __tstate = wxPyBeginAllowThreads();
8121 result = (wxWindow *)(arg1)->GetWindow();
8122 wxPyEndAllowThreads(__tstate);
8123 if (PyErr_Occurred()) SWIG_fail;
8124 }
8125 {
8126 resultobj = wxPyMake_wxObject(result, 0);
8127 }
8128 return resultobj;
8129 fail:
8130 return NULL;
8131 }
8132
8133
8134 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8135 PyObject *resultobj = 0;
8136 bool arg1 ;
8137 bool val1 ;
8138 int ecode1 = 0 ;
8139 PyObject * obj0 = 0 ;
8140 char * kwnames[] = {
8141 (char *) "flag", NULL
8142 };
8143
8144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8145 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8146 if (!SWIG_IsOK(ecode1)) {
8147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8148 }
8149 arg1 = static_cast< bool >(val1);
8150 {
8151 PyThreadState* __tstate = wxPyBeginAllowThreads();
8152 wxToolTip::Enable(arg1);
8153 wxPyEndAllowThreads(__tstate);
8154 if (PyErr_Occurred()) SWIG_fail;
8155 }
8156 resultobj = SWIG_Py_Void();
8157 return resultobj;
8158 fail:
8159 return NULL;
8160 }
8161
8162
8163 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj = 0;
8165 long arg1 ;
8166 long val1 ;
8167 int ecode1 = 0 ;
8168 PyObject * obj0 = 0 ;
8169 char * kwnames[] = {
8170 (char *) "milliseconds", NULL
8171 };
8172
8173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8174 ecode1 = SWIG_AsVal_long(obj0, &val1);
8175 if (!SWIG_IsOK(ecode1)) {
8176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8177 }
8178 arg1 = static_cast< long >(val1);
8179 {
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 wxToolTip::SetDelay(arg1);
8182 wxPyEndAllowThreads(__tstate);
8183 if (PyErr_Occurred()) SWIG_fail;
8184 }
8185 resultobj = SWIG_Py_Void();
8186 return resultobj;
8187 fail:
8188 return NULL;
8189 }
8190
8191
8192 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8193 PyObject *obj;
8194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8195 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8196 return SWIG_Py_Void();
8197 }
8198
8199 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8200 return SWIG_Python_InitShadowInstance(args);
8201 }
8202
8203 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8204 PyObject *resultobj = 0;
8205 wxWindow *arg1 = (wxWindow *) 0 ;
8206 wxSize *arg2 = 0 ;
8207 wxCaret *result = 0 ;
8208 void *argp1 = 0 ;
8209 int res1 = 0 ;
8210 wxSize temp2 ;
8211 PyObject * obj0 = 0 ;
8212 PyObject * obj1 = 0 ;
8213 char * kwnames[] = {
8214 (char *) "window",(char *) "size", NULL
8215 };
8216
8217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8219 if (!SWIG_IsOK(res1)) {
8220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8221 }
8222 arg1 = reinterpret_cast< wxWindow * >(argp1);
8223 {
8224 arg2 = &temp2;
8225 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8226 }
8227 {
8228 if (!wxPyCheckForApp()) SWIG_fail;
8229 PyThreadState* __tstate = wxPyBeginAllowThreads();
8230 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8231 wxPyEndAllowThreads(__tstate);
8232 if (PyErr_Occurred()) SWIG_fail;
8233 }
8234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8235 return resultobj;
8236 fail:
8237 return NULL;
8238 }
8239
8240
8241 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8242 PyObject *resultobj = 0;
8243 wxCaret *arg1 = (wxCaret *) 0 ;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 PyObject *swig_obj[1] ;
8247
8248 if (!args) SWIG_fail;
8249 swig_obj[0] = args;
8250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8251 if (!SWIG_IsOK(res1)) {
8252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8253 }
8254 arg1 = reinterpret_cast< wxCaret * >(argp1);
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 delete arg1;
8258
8259 wxPyEndAllowThreads(__tstate);
8260 if (PyErr_Occurred()) SWIG_fail;
8261 }
8262 resultobj = SWIG_Py_Void();
8263 return resultobj;
8264 fail:
8265 return NULL;
8266 }
8267
8268
8269 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8270 PyObject *resultobj = 0;
8271 wxCaret *arg1 = (wxCaret *) 0 ;
8272 void *argp1 = 0 ;
8273 int res1 = 0 ;
8274 PyObject *swig_obj[1] ;
8275
8276 if (!args) SWIG_fail;
8277 swig_obj[0] = args;
8278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8279 if (!SWIG_IsOK(res1)) {
8280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8281 }
8282 arg1 = reinterpret_cast< wxCaret * >(argp1);
8283 {
8284 PyThreadState* __tstate = wxPyBeginAllowThreads();
8285 wxCaret_Destroy(arg1);
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 resultobj = SWIG_Py_Void();
8290 return resultobj;
8291 fail:
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8297 PyObject *resultobj = 0;
8298 wxCaret *arg1 = (wxCaret *) 0 ;
8299 bool result;
8300 void *argp1 = 0 ;
8301 int res1 = 0 ;
8302 PyObject *swig_obj[1] ;
8303
8304 if (!args) SWIG_fail;
8305 swig_obj[0] = args;
8306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8307 if (!SWIG_IsOK(res1)) {
8308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8309 }
8310 arg1 = reinterpret_cast< wxCaret * >(argp1);
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (bool)(arg1)->IsOk();
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 {
8318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8319 }
8320 return resultobj;
8321 fail:
8322 return NULL;
8323 }
8324
8325
8326 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8327 PyObject *resultobj = 0;
8328 wxCaret *arg1 = (wxCaret *) 0 ;
8329 bool result;
8330 void *argp1 = 0 ;
8331 int res1 = 0 ;
8332 PyObject *swig_obj[1] ;
8333
8334 if (!args) SWIG_fail;
8335 swig_obj[0] = args;
8336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8337 if (!SWIG_IsOK(res1)) {
8338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8339 }
8340 arg1 = reinterpret_cast< wxCaret * >(argp1);
8341 {
8342 PyThreadState* __tstate = wxPyBeginAllowThreads();
8343 result = (bool)(arg1)->IsVisible();
8344 wxPyEndAllowThreads(__tstate);
8345 if (PyErr_Occurred()) SWIG_fail;
8346 }
8347 {
8348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8349 }
8350 return resultobj;
8351 fail:
8352 return NULL;
8353 }
8354
8355
8356 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8357 PyObject *resultobj = 0;
8358 wxCaret *arg1 = (wxCaret *) 0 ;
8359 wxPoint result;
8360 void *argp1 = 0 ;
8361 int res1 = 0 ;
8362 PyObject *swig_obj[1] ;
8363
8364 if (!args) SWIG_fail;
8365 swig_obj[0] = args;
8366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8367 if (!SWIG_IsOK(res1)) {
8368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8369 }
8370 arg1 = reinterpret_cast< wxCaret * >(argp1);
8371 {
8372 PyThreadState* __tstate = wxPyBeginAllowThreads();
8373 result = (arg1)->GetPosition();
8374 wxPyEndAllowThreads(__tstate);
8375 if (PyErr_Occurred()) SWIG_fail;
8376 }
8377 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8378 return resultobj;
8379 fail:
8380 return NULL;
8381 }
8382
8383
8384 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8385 PyObject *resultobj = 0;
8386 wxCaret *arg1 = (wxCaret *) 0 ;
8387 int *arg2 = (int *) 0 ;
8388 int *arg3 = (int *) 0 ;
8389 void *argp1 = 0 ;
8390 int res1 = 0 ;
8391 int temp2 ;
8392 int res2 = SWIG_TMPOBJ ;
8393 int temp3 ;
8394 int res3 = SWIG_TMPOBJ ;
8395 PyObject *swig_obj[1] ;
8396
8397 arg2 = &temp2;
8398 arg3 = &temp3;
8399 if (!args) SWIG_fail;
8400 swig_obj[0] = args;
8401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8402 if (!SWIG_IsOK(res1)) {
8403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8404 }
8405 arg1 = reinterpret_cast< wxCaret * >(argp1);
8406 {
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 (arg1)->GetPosition(arg2,arg3);
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_Py_Void();
8413 if (SWIG_IsTmpObj(res2)) {
8414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8415 } else {
8416 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8418 }
8419 if (SWIG_IsTmpObj(res3)) {
8420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8421 } else {
8422 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8424 }
8425 return resultobj;
8426 fail:
8427 return NULL;
8428 }
8429
8430
8431 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8432 PyObject *resultobj = 0;
8433 wxCaret *arg1 = (wxCaret *) 0 ;
8434 wxSize result;
8435 void *argp1 = 0 ;
8436 int res1 = 0 ;
8437 PyObject *swig_obj[1] ;
8438
8439 if (!args) SWIG_fail;
8440 swig_obj[0] = args;
8441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8442 if (!SWIG_IsOK(res1)) {
8443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8444 }
8445 arg1 = reinterpret_cast< wxCaret * >(argp1);
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (arg1)->GetSize();
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8453 return resultobj;
8454 fail:
8455 return NULL;
8456 }
8457
8458
8459 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8460 PyObject *resultobj = 0;
8461 wxCaret *arg1 = (wxCaret *) 0 ;
8462 int *arg2 = (int *) 0 ;
8463 int *arg3 = (int *) 0 ;
8464 void *argp1 = 0 ;
8465 int res1 = 0 ;
8466 int temp2 ;
8467 int res2 = SWIG_TMPOBJ ;
8468 int temp3 ;
8469 int res3 = SWIG_TMPOBJ ;
8470 PyObject *swig_obj[1] ;
8471
8472 arg2 = &temp2;
8473 arg3 = &temp3;
8474 if (!args) SWIG_fail;
8475 swig_obj[0] = args;
8476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8477 if (!SWIG_IsOK(res1)) {
8478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8479 }
8480 arg1 = reinterpret_cast< wxCaret * >(argp1);
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 (arg1)->GetSize(arg2,arg3);
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 resultobj = SWIG_Py_Void();
8488 if (SWIG_IsTmpObj(res2)) {
8489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8490 } else {
8491 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8493 }
8494 if (SWIG_IsTmpObj(res3)) {
8495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8496 } else {
8497 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8499 }
8500 return resultobj;
8501 fail:
8502 return NULL;
8503 }
8504
8505
8506 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8507 PyObject *resultobj = 0;
8508 wxCaret *arg1 = (wxCaret *) 0 ;
8509 wxWindow *result = 0 ;
8510 void *argp1 = 0 ;
8511 int res1 = 0 ;
8512 PyObject *swig_obj[1] ;
8513
8514 if (!args) SWIG_fail;
8515 swig_obj[0] = args;
8516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8517 if (!SWIG_IsOK(res1)) {
8518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8519 }
8520 arg1 = reinterpret_cast< wxCaret * >(argp1);
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 result = (wxWindow *)(arg1)->GetWindow();
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 {
8528 resultobj = wxPyMake_wxObject(result, 0);
8529 }
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj = 0;
8538 wxCaret *arg1 = (wxCaret *) 0 ;
8539 int arg2 ;
8540 int arg3 ;
8541 void *argp1 = 0 ;
8542 int res1 = 0 ;
8543 int val2 ;
8544 int ecode2 = 0 ;
8545 int val3 ;
8546 int ecode3 = 0 ;
8547 PyObject * obj0 = 0 ;
8548 PyObject * obj1 = 0 ;
8549 PyObject * obj2 = 0 ;
8550 char * kwnames[] = {
8551 (char *) "self",(char *) "x",(char *) "y", NULL
8552 };
8553
8554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8558 }
8559 arg1 = reinterpret_cast< wxCaret * >(argp1);
8560 ecode2 = SWIG_AsVal_int(obj1, &val2);
8561 if (!SWIG_IsOK(ecode2)) {
8562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8563 }
8564 arg2 = static_cast< int >(val2);
8565 ecode3 = SWIG_AsVal_int(obj2, &val3);
8566 if (!SWIG_IsOK(ecode3)) {
8567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8568 }
8569 arg3 = static_cast< int >(val3);
8570 {
8571 PyThreadState* __tstate = wxPyBeginAllowThreads();
8572 (arg1)->Move(arg2,arg3);
8573 wxPyEndAllowThreads(__tstate);
8574 if (PyErr_Occurred()) SWIG_fail;
8575 }
8576 resultobj = SWIG_Py_Void();
8577 return resultobj;
8578 fail:
8579 return NULL;
8580 }
8581
8582
8583 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8584 PyObject *resultobj = 0;
8585 wxCaret *arg1 = (wxCaret *) 0 ;
8586 wxPoint *arg2 = 0 ;
8587 void *argp1 = 0 ;
8588 int res1 = 0 ;
8589 wxPoint temp2 ;
8590 PyObject * obj0 = 0 ;
8591 PyObject * obj1 = 0 ;
8592 char * kwnames[] = {
8593 (char *) "self",(char *) "pt", NULL
8594 };
8595
8596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8598 if (!SWIG_IsOK(res1)) {
8599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8600 }
8601 arg1 = reinterpret_cast< wxCaret * >(argp1);
8602 {
8603 arg2 = &temp2;
8604 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8605 }
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 (arg1)->Move((wxPoint const &)*arg2);
8609 wxPyEndAllowThreads(__tstate);
8610 if (PyErr_Occurred()) SWIG_fail;
8611 }
8612 resultobj = SWIG_Py_Void();
8613 return resultobj;
8614 fail:
8615 return NULL;
8616 }
8617
8618
8619 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8620 PyObject *resultobj = 0;
8621 wxCaret *arg1 = (wxCaret *) 0 ;
8622 int arg2 ;
8623 int arg3 ;
8624 void *argp1 = 0 ;
8625 int res1 = 0 ;
8626 int val2 ;
8627 int ecode2 = 0 ;
8628 int val3 ;
8629 int ecode3 = 0 ;
8630 PyObject * obj0 = 0 ;
8631 PyObject * obj1 = 0 ;
8632 PyObject * obj2 = 0 ;
8633 char * kwnames[] = {
8634 (char *) "self",(char *) "width",(char *) "height", NULL
8635 };
8636
8637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8639 if (!SWIG_IsOK(res1)) {
8640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8641 }
8642 arg1 = reinterpret_cast< wxCaret * >(argp1);
8643 ecode2 = SWIG_AsVal_int(obj1, &val2);
8644 if (!SWIG_IsOK(ecode2)) {
8645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8646 }
8647 arg2 = static_cast< int >(val2);
8648 ecode3 = SWIG_AsVal_int(obj2, &val3);
8649 if (!SWIG_IsOK(ecode3)) {
8650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8651 }
8652 arg3 = static_cast< int >(val3);
8653 {
8654 PyThreadState* __tstate = wxPyBeginAllowThreads();
8655 (arg1)->SetSize(arg2,arg3);
8656 wxPyEndAllowThreads(__tstate);
8657 if (PyErr_Occurred()) SWIG_fail;
8658 }
8659 resultobj = SWIG_Py_Void();
8660 return resultobj;
8661 fail:
8662 return NULL;
8663 }
8664
8665
8666 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8667 PyObject *resultobj = 0;
8668 wxCaret *arg1 = (wxCaret *) 0 ;
8669 wxSize *arg2 = 0 ;
8670 void *argp1 = 0 ;
8671 int res1 = 0 ;
8672 wxSize temp2 ;
8673 PyObject * obj0 = 0 ;
8674 PyObject * obj1 = 0 ;
8675 char * kwnames[] = {
8676 (char *) "self",(char *) "size", NULL
8677 };
8678
8679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8681 if (!SWIG_IsOK(res1)) {
8682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8683 }
8684 arg1 = reinterpret_cast< wxCaret * >(argp1);
8685 {
8686 arg2 = &temp2;
8687 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8688 }
8689 {
8690 PyThreadState* __tstate = wxPyBeginAllowThreads();
8691 (arg1)->SetSize((wxSize const &)*arg2);
8692 wxPyEndAllowThreads(__tstate);
8693 if (PyErr_Occurred()) SWIG_fail;
8694 }
8695 resultobj = SWIG_Py_Void();
8696 return resultobj;
8697 fail:
8698 return NULL;
8699 }
8700
8701
8702 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8703 PyObject *resultobj = 0;
8704 wxCaret *arg1 = (wxCaret *) 0 ;
8705 int arg2 = (int) true ;
8706 void *argp1 = 0 ;
8707 int res1 = 0 ;
8708 int val2 ;
8709 int ecode2 = 0 ;
8710 PyObject * obj0 = 0 ;
8711 PyObject * obj1 = 0 ;
8712 char * kwnames[] = {
8713 (char *) "self",(char *) "show", NULL
8714 };
8715
8716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8718 if (!SWIG_IsOK(res1)) {
8719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8720 }
8721 arg1 = reinterpret_cast< wxCaret * >(argp1);
8722 if (obj1) {
8723 ecode2 = SWIG_AsVal_int(obj1, &val2);
8724 if (!SWIG_IsOK(ecode2)) {
8725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8726 }
8727 arg2 = static_cast< int >(val2);
8728 }
8729 {
8730 PyThreadState* __tstate = wxPyBeginAllowThreads();
8731 (arg1)->Show(arg2);
8732 wxPyEndAllowThreads(__tstate);
8733 if (PyErr_Occurred()) SWIG_fail;
8734 }
8735 resultobj = SWIG_Py_Void();
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8743 PyObject *resultobj = 0;
8744 wxCaret *arg1 = (wxCaret *) 0 ;
8745 void *argp1 = 0 ;
8746 int res1 = 0 ;
8747 PyObject *swig_obj[1] ;
8748
8749 if (!args) SWIG_fail;
8750 swig_obj[0] = args;
8751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8752 if (!SWIG_IsOK(res1)) {
8753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8754 }
8755 arg1 = reinterpret_cast< wxCaret * >(argp1);
8756 {
8757 PyThreadState* __tstate = wxPyBeginAllowThreads();
8758 (arg1)->Hide();
8759 wxPyEndAllowThreads(__tstate);
8760 if (PyErr_Occurred()) SWIG_fail;
8761 }
8762 resultobj = SWIG_Py_Void();
8763 return resultobj;
8764 fail:
8765 return NULL;
8766 }
8767
8768
8769 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8770 PyObject *resultobj = 0;
8771 int result;
8772
8773 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8774 {
8775 PyThreadState* __tstate = wxPyBeginAllowThreads();
8776 result = (int)wxCaret::GetBlinkTime();
8777 wxPyEndAllowThreads(__tstate);
8778 if (PyErr_Occurred()) SWIG_fail;
8779 }
8780 resultobj = SWIG_From_int(static_cast< int >(result));
8781 return resultobj;
8782 fail:
8783 return NULL;
8784 }
8785
8786
8787 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8788 PyObject *resultobj = 0;
8789 int arg1 ;
8790 int val1 ;
8791 int ecode1 = 0 ;
8792 PyObject * obj0 = 0 ;
8793 char * kwnames[] = {
8794 (char *) "milliseconds", NULL
8795 };
8796
8797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8798 ecode1 = SWIG_AsVal_int(obj0, &val1);
8799 if (!SWIG_IsOK(ecode1)) {
8800 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8801 }
8802 arg1 = static_cast< int >(val1);
8803 {
8804 PyThreadState* __tstate = wxPyBeginAllowThreads();
8805 wxCaret::SetBlinkTime(arg1);
8806 wxPyEndAllowThreads(__tstate);
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 resultobj = SWIG_Py_Void();
8810 return resultobj;
8811 fail:
8812 return NULL;
8813 }
8814
8815
8816 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8817 PyObject *obj;
8818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8819 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8820 return SWIG_Py_Void();
8821 }
8822
8823 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8824 return SWIG_Python_InitShadowInstance(args);
8825 }
8826
8827 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8828 PyObject *resultobj = 0;
8829 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8830 wxBusyCursor *result = 0 ;
8831 void *argp1 = 0 ;
8832 int res1 = 0 ;
8833 PyObject * obj0 = 0 ;
8834 char * kwnames[] = {
8835 (char *) "cursor", NULL
8836 };
8837
8838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8839 if (obj0) {
8840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8843 }
8844 arg1 = reinterpret_cast< wxCursor * >(argp1);
8845 }
8846 {
8847 if (!wxPyCheckForApp()) SWIG_fail;
8848 PyThreadState* __tstate = wxPyBeginAllowThreads();
8849 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8850 wxPyEndAllowThreads(__tstate);
8851 if (PyErr_Occurred()) SWIG_fail;
8852 }
8853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8854 return resultobj;
8855 fail:
8856 return NULL;
8857 }
8858
8859
8860 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8861 PyObject *resultobj = 0;
8862 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8863 void *argp1 = 0 ;
8864 int res1 = 0 ;
8865 PyObject *swig_obj[1] ;
8866
8867 if (!args) SWIG_fail;
8868 swig_obj[0] = args;
8869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8870 if (!SWIG_IsOK(res1)) {
8871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8872 }
8873 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8874 {
8875 PyThreadState* __tstate = wxPyBeginAllowThreads();
8876 delete arg1;
8877
8878 wxPyEndAllowThreads(__tstate);
8879 if (PyErr_Occurred()) SWIG_fail;
8880 }
8881 resultobj = SWIG_Py_Void();
8882 return resultobj;
8883 fail:
8884 return NULL;
8885 }
8886
8887
8888 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8889 PyObject *obj;
8890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8891 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8892 return SWIG_Py_Void();
8893 }
8894
8895 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8896 return SWIG_Python_InitShadowInstance(args);
8897 }
8898
8899 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8900 PyObject *resultobj = 0;
8901 wxWindow *arg1 = (wxWindow *) NULL ;
8902 wxWindowDisabler *result = 0 ;
8903 void *argp1 = 0 ;
8904 int res1 = 0 ;
8905 PyObject * obj0 = 0 ;
8906 char * kwnames[] = {
8907 (char *) "winToSkip", NULL
8908 };
8909
8910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8911 if (obj0) {
8912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8913 if (!SWIG_IsOK(res1)) {
8914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8915 }
8916 arg1 = reinterpret_cast< wxWindow * >(argp1);
8917 }
8918 {
8919 if (!wxPyCheckForApp()) SWIG_fail;
8920 PyThreadState* __tstate = wxPyBeginAllowThreads();
8921 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8922 wxPyEndAllowThreads(__tstate);
8923 if (PyErr_Occurred()) SWIG_fail;
8924 }
8925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8926 return resultobj;
8927 fail:
8928 return NULL;
8929 }
8930
8931
8932 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8933 PyObject *resultobj = 0;
8934 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8935 void *argp1 = 0 ;
8936 int res1 = 0 ;
8937 PyObject *swig_obj[1] ;
8938
8939 if (!args) SWIG_fail;
8940 swig_obj[0] = args;
8941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8942 if (!SWIG_IsOK(res1)) {
8943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8944 }
8945 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 delete arg1;
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 resultobj = SWIG_Py_Void();
8954 return resultobj;
8955 fail:
8956 return NULL;
8957 }
8958
8959
8960 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8961 PyObject *obj;
8962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8963 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8964 return SWIG_Py_Void();
8965 }
8966
8967 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8968 return SWIG_Python_InitShadowInstance(args);
8969 }
8970
8971 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8972 PyObject *resultobj = 0;
8973 wxString *arg1 = 0 ;
8974 wxBusyInfo *result = 0 ;
8975 bool temp1 = false ;
8976 PyObject * obj0 = 0 ;
8977 char * kwnames[] = {
8978 (char *) "message", NULL
8979 };
8980
8981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8982 {
8983 arg1 = wxString_in_helper(obj0);
8984 if (arg1 == NULL) SWIG_fail;
8985 temp1 = true;
8986 }
8987 {
8988 if (!wxPyCheckForApp()) SWIG_fail;
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8995 {
8996 if (temp1)
8997 delete arg1;
8998 }
8999 return resultobj;
9000 fail:
9001 {
9002 if (temp1)
9003 delete arg1;
9004 }
9005 return NULL;
9006 }
9007
9008
9009 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9010 PyObject *resultobj = 0;
9011 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9012 void *argp1 = 0 ;
9013 int res1 = 0 ;
9014 PyObject *swig_obj[1] ;
9015
9016 if (!args) SWIG_fail;
9017 swig_obj[0] = args;
9018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9019 if (!SWIG_IsOK(res1)) {
9020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9021 }
9022 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 delete arg1;
9026
9027 wxPyEndAllowThreads(__tstate);
9028 if (PyErr_Occurred()) SWIG_fail;
9029 }
9030 resultobj = SWIG_Py_Void();
9031 return resultobj;
9032 fail:
9033 return NULL;
9034 }
9035
9036
9037 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9038 PyObject *obj;
9039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9040 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9041 return SWIG_Py_Void();
9042 }
9043
9044 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045 return SWIG_Python_InitShadowInstance(args);
9046 }
9047
9048 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxStopWatch *result = 0 ;
9051
9052 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9053 {
9054 PyThreadState* __tstate = wxPyBeginAllowThreads();
9055 result = (wxStopWatch *)new wxStopWatch();
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9067 PyObject *resultobj = 0;
9068 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9069 long arg2 = (long) 0 ;
9070 void *argp1 = 0 ;
9071 int res1 = 0 ;
9072 long val2 ;
9073 int ecode2 = 0 ;
9074 PyObject * obj0 = 0 ;
9075 PyObject * obj1 = 0 ;
9076 char * kwnames[] = {
9077 (char *) "self",(char *) "t0", NULL
9078 };
9079
9080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9082 if (!SWIG_IsOK(res1)) {
9083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9084 }
9085 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9086 if (obj1) {
9087 ecode2 = SWIG_AsVal_long(obj1, &val2);
9088 if (!SWIG_IsOK(ecode2)) {
9089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9090 }
9091 arg2 = static_cast< long >(val2);
9092 }
9093 {
9094 PyThreadState* __tstate = wxPyBeginAllowThreads();
9095 (arg1)->Start(arg2);
9096 wxPyEndAllowThreads(__tstate);
9097 if (PyErr_Occurred()) SWIG_fail;
9098 }
9099 resultobj = SWIG_Py_Void();
9100 return resultobj;
9101 fail:
9102 return NULL;
9103 }
9104
9105
9106 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9107 PyObject *resultobj = 0;
9108 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9109 void *argp1 = 0 ;
9110 int res1 = 0 ;
9111 PyObject *swig_obj[1] ;
9112
9113 if (!args) SWIG_fail;
9114 swig_obj[0] = args;
9115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9116 if (!SWIG_IsOK(res1)) {
9117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9118 }
9119 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9120 {
9121 PyThreadState* __tstate = wxPyBeginAllowThreads();
9122 (arg1)->Pause();
9123 wxPyEndAllowThreads(__tstate);
9124 if (PyErr_Occurred()) SWIG_fail;
9125 }
9126 resultobj = SWIG_Py_Void();
9127 return resultobj;
9128 fail:
9129 return NULL;
9130 }
9131
9132
9133 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9134 PyObject *resultobj = 0;
9135 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9136 void *argp1 = 0 ;
9137 int res1 = 0 ;
9138 PyObject *swig_obj[1] ;
9139
9140 if (!args) SWIG_fail;
9141 swig_obj[0] = args;
9142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9143 if (!SWIG_IsOK(res1)) {
9144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9145 }
9146 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9147 {
9148 PyThreadState* __tstate = wxPyBeginAllowThreads();
9149 (arg1)->Resume();
9150 wxPyEndAllowThreads(__tstate);
9151 if (PyErr_Occurred()) SWIG_fail;
9152 }
9153 resultobj = SWIG_Py_Void();
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9161 PyObject *resultobj = 0;
9162 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9163 long result;
9164 void *argp1 = 0 ;
9165 int res1 = 0 ;
9166 PyObject *swig_obj[1] ;
9167
9168 if (!args) SWIG_fail;
9169 swig_obj[0] = args;
9170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9171 if (!SWIG_IsOK(res1)) {
9172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9173 }
9174 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9175 {
9176 PyThreadState* __tstate = wxPyBeginAllowThreads();
9177 result = (long)((wxStopWatch const *)arg1)->Time();
9178 wxPyEndAllowThreads(__tstate);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 resultobj = SWIG_From_long(static_cast< long >(result));
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9189 PyObject *obj;
9190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9191 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9192 return SWIG_Py_Void();
9193 }
9194
9195 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9196 return SWIG_Python_InitShadowInstance(args);
9197 }
9198
9199 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9200 PyObject *resultobj = 0;
9201 int arg1 = (int) 9 ;
9202 int arg2 = (int) wxID_FILE1 ;
9203 wxFileHistory *result = 0 ;
9204 int val1 ;
9205 int ecode1 = 0 ;
9206 int val2 ;
9207 int ecode2 = 0 ;
9208 PyObject * obj0 = 0 ;
9209 PyObject * obj1 = 0 ;
9210 char * kwnames[] = {
9211 (char *) "maxFiles",(char *) "idBase", NULL
9212 };
9213
9214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9215 if (obj0) {
9216 ecode1 = SWIG_AsVal_int(obj0, &val1);
9217 if (!SWIG_IsOK(ecode1)) {
9218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9219 }
9220 arg1 = static_cast< int >(val1);
9221 }
9222 if (obj1) {
9223 ecode2 = SWIG_AsVal_int(obj1, &val2);
9224 if (!SWIG_IsOK(ecode2)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9226 }
9227 arg2 = static_cast< int >(val2);
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9243 PyObject *resultobj = 0;
9244 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9245 void *argp1 = 0 ;
9246 int res1 = 0 ;
9247 PyObject *swig_obj[1] ;
9248
9249 if (!args) SWIG_fail;
9250 swig_obj[0] = args;
9251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9252 if (!SWIG_IsOK(res1)) {
9253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9254 }
9255 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9256 {
9257 PyThreadState* __tstate = wxPyBeginAllowThreads();
9258 delete arg1;
9259
9260 wxPyEndAllowThreads(__tstate);
9261 if (PyErr_Occurred()) SWIG_fail;
9262 }
9263 resultobj = SWIG_Py_Void();
9264 return resultobj;
9265 fail:
9266 return NULL;
9267 }
9268
9269
9270 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9271 PyObject *resultobj = 0;
9272 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9273 wxString *arg2 = 0 ;
9274 void *argp1 = 0 ;
9275 int res1 = 0 ;
9276 bool temp2 = false ;
9277 PyObject * obj0 = 0 ;
9278 PyObject * obj1 = 0 ;
9279 char * kwnames[] = {
9280 (char *) "self",(char *) "file", NULL
9281 };
9282
9283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9285 if (!SWIG_IsOK(res1)) {
9286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9287 }
9288 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9289 {
9290 arg2 = wxString_in_helper(obj1);
9291 if (arg2 == NULL) SWIG_fail;
9292 temp2 = true;
9293 }
9294 {
9295 PyThreadState* __tstate = wxPyBeginAllowThreads();
9296 (arg1)->AddFileToHistory((wxString const &)*arg2);
9297 wxPyEndAllowThreads(__tstate);
9298 if (PyErr_Occurred()) SWIG_fail;
9299 }
9300 resultobj = SWIG_Py_Void();
9301 {
9302 if (temp2)
9303 delete arg2;
9304 }
9305 return resultobj;
9306 fail:
9307 {
9308 if (temp2)
9309 delete arg2;
9310 }
9311 return NULL;
9312 }
9313
9314
9315 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj = 0;
9317 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9318 int arg2 ;
9319 void *argp1 = 0 ;
9320 int res1 = 0 ;
9321 int val2 ;
9322 int ecode2 = 0 ;
9323 PyObject * obj0 = 0 ;
9324 PyObject * obj1 = 0 ;
9325 char * kwnames[] = {
9326 (char *) "self",(char *) "i", NULL
9327 };
9328
9329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9331 if (!SWIG_IsOK(res1)) {
9332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9333 }
9334 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9335 ecode2 = SWIG_AsVal_int(obj1, &val2);
9336 if (!SWIG_IsOK(ecode2)) {
9337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9338 }
9339 arg2 = static_cast< int >(val2);
9340 {
9341 PyThreadState* __tstate = wxPyBeginAllowThreads();
9342 (arg1)->RemoveFileFromHistory(arg2);
9343 wxPyEndAllowThreads(__tstate);
9344 if (PyErr_Occurred()) SWIG_fail;
9345 }
9346 resultobj = SWIG_Py_Void();
9347 return resultobj;
9348 fail:
9349 return NULL;
9350 }
9351
9352
9353 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9354 PyObject *resultobj = 0;
9355 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9356 int result;
9357 void *argp1 = 0 ;
9358 int res1 = 0 ;
9359 PyObject *swig_obj[1] ;
9360
9361 if (!args) SWIG_fail;
9362 swig_obj[0] = args;
9363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9364 if (!SWIG_IsOK(res1)) {
9365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9366 }
9367 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9368 {
9369 PyThreadState* __tstate = wxPyBeginAllowThreads();
9370 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9371 wxPyEndAllowThreads(__tstate);
9372 if (PyErr_Occurred()) SWIG_fail;
9373 }
9374 resultobj = SWIG_From_int(static_cast< int >(result));
9375 return resultobj;
9376 fail:
9377 return NULL;
9378 }
9379
9380
9381 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9382 PyObject *resultobj = 0;
9383 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9384 wxMenu *arg2 = (wxMenu *) 0 ;
9385 void *argp1 = 0 ;
9386 int res1 = 0 ;
9387 void *argp2 = 0 ;
9388 int res2 = 0 ;
9389 PyObject * obj0 = 0 ;
9390 PyObject * obj1 = 0 ;
9391 char * kwnames[] = {
9392 (char *) "self",(char *) "menu", NULL
9393 };
9394
9395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9397 if (!SWIG_IsOK(res1)) {
9398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9399 }
9400 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9402 if (!SWIG_IsOK(res2)) {
9403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9404 }
9405 arg2 = reinterpret_cast< wxMenu * >(argp2);
9406 {
9407 PyThreadState* __tstate = wxPyBeginAllowThreads();
9408 (arg1)->UseMenu(arg2);
9409 wxPyEndAllowThreads(__tstate);
9410 if (PyErr_Occurred()) SWIG_fail;
9411 }
9412 resultobj = SWIG_Py_Void();
9413 return resultobj;
9414 fail:
9415 return NULL;
9416 }
9417
9418
9419 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9420 PyObject *resultobj = 0;
9421 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9422 wxMenu *arg2 = (wxMenu *) 0 ;
9423 void *argp1 = 0 ;
9424 int res1 = 0 ;
9425 void *argp2 = 0 ;
9426 int res2 = 0 ;
9427 PyObject * obj0 = 0 ;
9428 PyObject * obj1 = 0 ;
9429 char * kwnames[] = {
9430 (char *) "self",(char *) "menu", NULL
9431 };
9432
9433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9435 if (!SWIG_IsOK(res1)) {
9436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9437 }
9438 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9440 if (!SWIG_IsOK(res2)) {
9441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9442 }
9443 arg2 = reinterpret_cast< wxMenu * >(argp2);
9444 {
9445 PyThreadState* __tstate = wxPyBeginAllowThreads();
9446 (arg1)->RemoveMenu(arg2);
9447 wxPyEndAllowThreads(__tstate);
9448 if (PyErr_Occurred()) SWIG_fail;
9449 }
9450 resultobj = SWIG_Py_Void();
9451 return resultobj;
9452 fail:
9453 return NULL;
9454 }
9455
9456
9457 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9458 PyObject *resultobj = 0;
9459 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9460 wxConfigBase *arg2 = 0 ;
9461 void *argp1 = 0 ;
9462 int res1 = 0 ;
9463 void *argp2 = 0 ;
9464 int res2 = 0 ;
9465 PyObject * obj0 = 0 ;
9466 PyObject * obj1 = 0 ;
9467 char * kwnames[] = {
9468 (char *) "self",(char *) "config", NULL
9469 };
9470
9471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9473 if (!SWIG_IsOK(res1)) {
9474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9475 }
9476 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9477 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9478 if (!SWIG_IsOK(res2)) {
9479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9480 }
9481 if (!argp2) {
9482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9483 }
9484 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9485 {
9486 PyThreadState* __tstate = wxPyBeginAllowThreads();
9487 (arg1)->Load(*arg2);
9488 wxPyEndAllowThreads(__tstate);
9489 if (PyErr_Occurred()) SWIG_fail;
9490 }
9491 resultobj = SWIG_Py_Void();
9492 return resultobj;
9493 fail:
9494 return NULL;
9495 }
9496
9497
9498 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9499 PyObject *resultobj = 0;
9500 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9501 wxConfigBase *arg2 = 0 ;
9502 void *argp1 = 0 ;
9503 int res1 = 0 ;
9504 void *argp2 = 0 ;
9505 int res2 = 0 ;
9506 PyObject * obj0 = 0 ;
9507 PyObject * obj1 = 0 ;
9508 char * kwnames[] = {
9509 (char *) "self",(char *) "config", NULL
9510 };
9511
9512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9514 if (!SWIG_IsOK(res1)) {
9515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9516 }
9517 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9518 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9519 if (!SWIG_IsOK(res2)) {
9520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9521 }
9522 if (!argp2) {
9523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9524 }
9525 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9526 {
9527 PyThreadState* __tstate = wxPyBeginAllowThreads();
9528 (arg1)->Save(*arg2);
9529 wxPyEndAllowThreads(__tstate);
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 resultobj = SWIG_Py_Void();
9533 return resultobj;
9534 fail:
9535 return NULL;
9536 }
9537
9538
9539 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9540 PyObject *resultobj = 0;
9541 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9542 void *argp1 = 0 ;
9543 int res1 = 0 ;
9544 PyObject *swig_obj[1] ;
9545
9546 if (!args) SWIG_fail;
9547 swig_obj[0] = args;
9548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9549 if (!SWIG_IsOK(res1)) {
9550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9551 }
9552 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9553 {
9554 PyThreadState* __tstate = wxPyBeginAllowThreads();
9555 (arg1)->AddFilesToMenu();
9556 wxPyEndAllowThreads(__tstate);
9557 if (PyErr_Occurred()) SWIG_fail;
9558 }
9559 resultobj = SWIG_Py_Void();
9560 return resultobj;
9561 fail:
9562 return NULL;
9563 }
9564
9565
9566 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9567 PyObject *resultobj = 0;
9568 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9569 wxMenu *arg2 = (wxMenu *) 0 ;
9570 void *argp1 = 0 ;
9571 int res1 = 0 ;
9572 void *argp2 = 0 ;
9573 int res2 = 0 ;
9574 PyObject * obj0 = 0 ;
9575 PyObject * obj1 = 0 ;
9576 char * kwnames[] = {
9577 (char *) "self",(char *) "menu", NULL
9578 };
9579
9580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9582 if (!SWIG_IsOK(res1)) {
9583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9584 }
9585 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9587 if (!SWIG_IsOK(res2)) {
9588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9589 }
9590 arg2 = reinterpret_cast< wxMenu * >(argp2);
9591 {
9592 PyThreadState* __tstate = wxPyBeginAllowThreads();
9593 (arg1)->AddFilesToMenu(arg2);
9594 wxPyEndAllowThreads(__tstate);
9595 if (PyErr_Occurred()) SWIG_fail;
9596 }
9597 resultobj = SWIG_Py_Void();
9598 return resultobj;
9599 fail:
9600 return NULL;
9601 }
9602
9603
9604 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9605 PyObject *resultobj = 0;
9606 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9607 int arg2 ;
9608 wxString result;
9609 void *argp1 = 0 ;
9610 int res1 = 0 ;
9611 int val2 ;
9612 int ecode2 = 0 ;
9613 PyObject * obj0 = 0 ;
9614 PyObject * obj1 = 0 ;
9615 char * kwnames[] = {
9616 (char *) "self",(char *) "i", NULL
9617 };
9618
9619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9621 if (!SWIG_IsOK(res1)) {
9622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9623 }
9624 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9625 ecode2 = SWIG_AsVal_int(obj1, &val2);
9626 if (!SWIG_IsOK(ecode2)) {
9627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9628 }
9629 arg2 = static_cast< int >(val2);
9630 {
9631 PyThreadState* __tstate = wxPyBeginAllowThreads();
9632 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9633 wxPyEndAllowThreads(__tstate);
9634 if (PyErr_Occurred()) SWIG_fail;
9635 }
9636 {
9637 #if wxUSE_UNICODE
9638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9639 #else
9640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9641 #endif
9642 }
9643 return resultobj;
9644 fail:
9645 return NULL;
9646 }
9647
9648
9649 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9650 PyObject *resultobj = 0;
9651 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9652 int result;
9653 void *argp1 = 0 ;
9654 int res1 = 0 ;
9655 PyObject *swig_obj[1] ;
9656
9657 if (!args) SWIG_fail;
9658 swig_obj[0] = args;
9659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9660 if (!SWIG_IsOK(res1)) {
9661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9662 }
9663 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9664 {
9665 PyThreadState* __tstate = wxPyBeginAllowThreads();
9666 result = (int)((wxFileHistory const *)arg1)->GetCount();
9667 wxPyEndAllowThreads(__tstate);
9668 if (PyErr_Occurred()) SWIG_fail;
9669 }
9670 resultobj = SWIG_From_int(static_cast< int >(result));
9671 return resultobj;
9672 fail:
9673 return NULL;
9674 }
9675
9676
9677 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9678 PyObject *obj;
9679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9680 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9681 return SWIG_Py_Void();
9682 }
9683
9684 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9685 return SWIG_Python_InitShadowInstance(args);
9686 }
9687
9688 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9689 PyObject *resultobj = 0;
9690 wxString *arg1 = 0 ;
9691 wxString const &arg2_defvalue = wxPyEmptyString ;
9692 wxString *arg2 = (wxString *) &arg2_defvalue ;
9693 wxSingleInstanceChecker *result = 0 ;
9694 bool temp1 = false ;
9695 bool temp2 = false ;
9696 PyObject * obj0 = 0 ;
9697 PyObject * obj1 = 0 ;
9698 char * kwnames[] = {
9699 (char *) "name",(char *) "path", NULL
9700 };
9701
9702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9703 {
9704 arg1 = wxString_in_helper(obj0);
9705 if (arg1 == NULL) SWIG_fail;
9706 temp1 = true;
9707 }
9708 if (obj1) {
9709 {
9710 arg2 = wxString_in_helper(obj1);
9711 if (arg2 == NULL) SWIG_fail;
9712 temp2 = true;
9713 }
9714 }
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9722 {
9723 if (temp1)
9724 delete arg1;
9725 }
9726 {
9727 if (temp2)
9728 delete arg2;
9729 }
9730 return resultobj;
9731 fail:
9732 {
9733 if (temp1)
9734 delete arg1;
9735 }
9736 {
9737 if (temp2)
9738 delete arg2;
9739 }
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9745 PyObject *resultobj = 0;
9746 wxSingleInstanceChecker *result = 0 ;
9747
9748 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9749 {
9750 PyThreadState* __tstate = wxPyBeginAllowThreads();
9751 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9752 wxPyEndAllowThreads(__tstate);
9753 if (PyErr_Occurred()) SWIG_fail;
9754 }
9755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9756 return resultobj;
9757 fail:
9758 return NULL;
9759 }
9760
9761
9762 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9763 PyObject *resultobj = 0;
9764 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9765 void *argp1 = 0 ;
9766 int res1 = 0 ;
9767 PyObject *swig_obj[1] ;
9768
9769 if (!args) SWIG_fail;
9770 swig_obj[0] = args;
9771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9774 }
9775 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9776 {
9777 PyThreadState* __tstate = wxPyBeginAllowThreads();
9778 delete arg1;
9779
9780 wxPyEndAllowThreads(__tstate);
9781 if (PyErr_Occurred()) SWIG_fail;
9782 }
9783 resultobj = SWIG_Py_Void();
9784 return resultobj;
9785 fail:
9786 return NULL;
9787 }
9788
9789
9790 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9791 PyObject *resultobj = 0;
9792 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9793 wxString *arg2 = 0 ;
9794 wxString const &arg3_defvalue = wxPyEmptyString ;
9795 wxString *arg3 = (wxString *) &arg3_defvalue ;
9796 bool result;
9797 void *argp1 = 0 ;
9798 int res1 = 0 ;
9799 bool temp2 = false ;
9800 bool temp3 = false ;
9801 PyObject * obj0 = 0 ;
9802 PyObject * obj1 = 0 ;
9803 PyObject * obj2 = 0 ;
9804 char * kwnames[] = {
9805 (char *) "self",(char *) "name",(char *) "path", NULL
9806 };
9807
9808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9810 if (!SWIG_IsOK(res1)) {
9811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9812 }
9813 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9814 {
9815 arg2 = wxString_in_helper(obj1);
9816 if (arg2 == NULL) SWIG_fail;
9817 temp2 = true;
9818 }
9819 if (obj2) {
9820 {
9821 arg3 = wxString_in_helper(obj2);
9822 if (arg3 == NULL) SWIG_fail;
9823 temp3 = true;
9824 }
9825 }
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9829 wxPyEndAllowThreads(__tstate);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 {
9833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9834 }
9835 {
9836 if (temp2)
9837 delete arg2;
9838 }
9839 {
9840 if (temp3)
9841 delete arg3;
9842 }
9843 return resultobj;
9844 fail:
9845 {
9846 if (temp2)
9847 delete arg2;
9848 }
9849 {
9850 if (temp3)
9851 delete arg3;
9852 }
9853 return NULL;
9854 }
9855
9856
9857 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9858 PyObject *resultobj = 0;
9859 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9860 bool result;
9861 void *argp1 = 0 ;
9862 int res1 = 0 ;
9863 PyObject *swig_obj[1] ;
9864
9865 if (!args) SWIG_fail;
9866 swig_obj[0] = args;
9867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9868 if (!SWIG_IsOK(res1)) {
9869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9870 }
9871 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9872 {
9873 PyThreadState* __tstate = wxPyBeginAllowThreads();
9874 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9875 wxPyEndAllowThreads(__tstate);
9876 if (PyErr_Occurred()) SWIG_fail;
9877 }
9878 {
9879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9880 }
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9888 PyObject *obj;
9889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9890 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9891 return SWIG_Py_Void();
9892 }
9893
9894 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9895 return SWIG_Python_InitShadowInstance(args);
9896 }
9897
9898 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9899 PyObject *resultobj = 0;
9900 wxWindow *arg1 = (wxWindow *) 0 ;
9901 wxDC *arg2 = 0 ;
9902 bool result;
9903 void *argp1 = 0 ;
9904 int res1 = 0 ;
9905 void *argp2 = 0 ;
9906 int res2 = 0 ;
9907 PyObject * obj0 = 0 ;
9908 PyObject * obj1 = 0 ;
9909 char * kwnames[] = {
9910 (char *) "window",(char *) "dc", NULL
9911 };
9912
9913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9915 if (!SWIG_IsOK(res1)) {
9916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9917 }
9918 arg1 = reinterpret_cast< wxWindow * >(argp1);
9919 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9920 if (!SWIG_IsOK(res2)) {
9921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9922 }
9923 if (!argp2) {
9924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9925 }
9926 arg2 = reinterpret_cast< wxDC * >(argp2);
9927 {
9928 PyThreadState* __tstate = wxPyBeginAllowThreads();
9929 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9930 wxPyEndAllowThreads(__tstate);
9931 if (PyErr_Occurred()) SWIG_fail;
9932 }
9933 {
9934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9935 }
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9943 PyObject *resultobj = 0;
9944 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9945 void *argp1 = 0 ;
9946 int res1 = 0 ;
9947 PyObject *swig_obj[1] ;
9948
9949 if (!args) SWIG_fail;
9950 swig_obj[0] = args;
9951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9952 if (!SWIG_IsOK(res1)) {
9953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9954 }
9955 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9956 {
9957 PyThreadState* __tstate = wxPyBeginAllowThreads();
9958 delete arg1;
9959
9960 wxPyEndAllowThreads(__tstate);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 resultobj = SWIG_Py_Void();
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9971 PyObject *resultobj = 0;
9972 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9973 wxString result;
9974 void *argp1 = 0 ;
9975 int res1 = 0 ;
9976 PyObject *swig_obj[1] ;
9977
9978 if (!args) SWIG_fail;
9979 swig_obj[0] = args;
9980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9981 if (!SWIG_IsOK(res1)) {
9982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9983 }
9984 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9985 {
9986 PyThreadState* __tstate = wxPyBeginAllowThreads();
9987 result = (arg1)->GetTip();
9988 wxPyEndAllowThreads(__tstate);
9989 if (PyErr_Occurred()) SWIG_fail;
9990 }
9991 {
9992 #if wxUSE_UNICODE
9993 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9994 #else
9995 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9996 #endif
9997 }
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10005 PyObject *resultobj = 0;
10006 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10007 size_t result;
10008 void *argp1 = 0 ;
10009 int res1 = 0 ;
10010 PyObject *swig_obj[1] ;
10011
10012 if (!args) SWIG_fail;
10013 swig_obj[0] = args;
10014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10015 if (!SWIG_IsOK(res1)) {
10016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10017 }
10018 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10019 {
10020 PyThreadState* __tstate = wxPyBeginAllowThreads();
10021 result = (size_t)(arg1)->GetCurrentTip();
10022 wxPyEndAllowThreads(__tstate);
10023 if (PyErr_Occurred()) SWIG_fail;
10024 }
10025 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10026 return resultobj;
10027 fail:
10028 return NULL;
10029 }
10030
10031
10032 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10033 PyObject *resultobj = 0;
10034 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10035 wxString *arg2 = 0 ;
10036 wxString result;
10037 void *argp1 = 0 ;
10038 int res1 = 0 ;
10039 bool temp2 = false ;
10040 PyObject * obj0 = 0 ;
10041 PyObject * obj1 = 0 ;
10042 char * kwnames[] = {
10043 (char *) "self",(char *) "tip", NULL
10044 };
10045
10046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10048 if (!SWIG_IsOK(res1)) {
10049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10050 }
10051 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10052 {
10053 arg2 = wxString_in_helper(obj1);
10054 if (arg2 == NULL) SWIG_fail;
10055 temp2 = true;
10056 }
10057 {
10058 PyThreadState* __tstate = wxPyBeginAllowThreads();
10059 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 {
10064 #if wxUSE_UNICODE
10065 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10066 #else
10067 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10068 #endif
10069 }
10070 {
10071 if (temp2)
10072 delete arg2;
10073 }
10074 return resultobj;
10075 fail:
10076 {
10077 if (temp2)
10078 delete arg2;
10079 }
10080 return NULL;
10081 }
10082
10083
10084 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10085 PyObject *obj;
10086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10087 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10088 return SWIG_Py_Void();
10089 }
10090
10091 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10092 PyObject *resultobj = 0;
10093 size_t arg1 ;
10094 wxPyTipProvider *result = 0 ;
10095 size_t val1 ;
10096 int ecode1 = 0 ;
10097 PyObject * obj0 = 0 ;
10098 char * kwnames[] = {
10099 (char *) "currentTip", NULL
10100 };
10101
10102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10103 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10104 if (!SWIG_IsOK(ecode1)) {
10105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10106 }
10107 arg1 = static_cast< size_t >(val1);
10108 {
10109 PyThreadState* __tstate = wxPyBeginAllowThreads();
10110 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10111 wxPyEndAllowThreads(__tstate);
10112 if (PyErr_Occurred()) SWIG_fail;
10113 }
10114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10115 return resultobj;
10116 fail:
10117 return NULL;
10118 }
10119
10120
10121 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10122 PyObject *resultobj = 0;
10123 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10124 PyObject *arg2 = (PyObject *) 0 ;
10125 PyObject *arg3 = (PyObject *) 0 ;
10126 void *argp1 = 0 ;
10127 int res1 = 0 ;
10128 PyObject * obj0 = 0 ;
10129 PyObject * obj1 = 0 ;
10130 PyObject * obj2 = 0 ;
10131 char * kwnames[] = {
10132 (char *) "self",(char *) "self",(char *) "_class", NULL
10133 };
10134
10135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10137 if (!SWIG_IsOK(res1)) {
10138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10139 }
10140 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10141 arg2 = obj1;
10142 arg3 = obj2;
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 (arg1)->_setCallbackInfo(arg2,arg3);
10146 wxPyEndAllowThreads(__tstate);
10147 if (PyErr_Occurred()) SWIG_fail;
10148 }
10149 resultobj = SWIG_Py_Void();
10150 return resultobj;
10151 fail:
10152 return NULL;
10153 }
10154
10155
10156 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10157 PyObject *obj;
10158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10160 return SWIG_Py_Void();
10161 }
10162
10163 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10164 return SWIG_Python_InitShadowInstance(args);
10165 }
10166
10167 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10168 PyObject *resultobj = 0;
10169 wxWindow *arg1 = (wxWindow *) 0 ;
10170 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10171 bool arg3 = (bool) true ;
10172 bool result;
10173 void *argp1 = 0 ;
10174 int res1 = 0 ;
10175 void *argp2 = 0 ;
10176 int res2 = 0 ;
10177 bool val3 ;
10178 int ecode3 = 0 ;
10179 PyObject * obj0 = 0 ;
10180 PyObject * obj1 = 0 ;
10181 PyObject * obj2 = 0 ;
10182 char * kwnames[] = {
10183 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10184 };
10185
10186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10188 if (!SWIG_IsOK(res1)) {
10189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10190 }
10191 arg1 = reinterpret_cast< wxWindow * >(argp1);
10192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10193 if (!SWIG_IsOK(res2)) {
10194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10195 }
10196 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10197 if (obj2) {
10198 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10199 if (!SWIG_IsOK(ecode3)) {
10200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10201 }
10202 arg3 = static_cast< bool >(val3);
10203 }
10204 {
10205 if (!wxPyCheckForApp()) SWIG_fail;
10206 PyThreadState* __tstate = wxPyBeginAllowThreads();
10207 result = (bool)wxShowTip(arg1,arg2,arg3);
10208 wxPyEndAllowThreads(__tstate);
10209 if (PyErr_Occurred()) SWIG_fail;
10210 }
10211 {
10212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10213 }
10214 return resultobj;
10215 fail:
10216 return NULL;
10217 }
10218
10219
10220 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10221 PyObject *resultobj = 0;
10222 wxString *arg1 = 0 ;
10223 size_t arg2 ;
10224 wxTipProvider *result = 0 ;
10225 bool temp1 = false ;
10226 size_t val2 ;
10227 int ecode2 = 0 ;
10228 PyObject * obj0 = 0 ;
10229 PyObject * obj1 = 0 ;
10230 char * kwnames[] = {
10231 (char *) "filename",(char *) "currentTip", NULL
10232 };
10233
10234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10235 {
10236 arg1 = wxString_in_helper(obj0);
10237 if (arg1 == NULL) SWIG_fail;
10238 temp1 = true;
10239 }
10240 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10241 if (!SWIG_IsOK(ecode2)) {
10242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10243 }
10244 arg2 = static_cast< size_t >(val2);
10245 {
10246 if (!wxPyCheckForApp()) SWIG_fail;
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10249 wxPyEndAllowThreads(__tstate);
10250 if (PyErr_Occurred()) SWIG_fail;
10251 }
10252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10253 {
10254 if (temp1)
10255 delete arg1;
10256 }
10257 return resultobj;
10258 fail:
10259 {
10260 if (temp1)
10261 delete arg1;
10262 }
10263 return NULL;
10264 }
10265
10266
10267 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10268 PyObject *resultobj = 0;
10269 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10270 int arg2 = (int) wxID_ANY ;
10271 wxPyTimer *result = 0 ;
10272 void *argp1 = 0 ;
10273 int res1 = 0 ;
10274 int val2 ;
10275 int ecode2 = 0 ;
10276 PyObject * obj0 = 0 ;
10277 PyObject * obj1 = 0 ;
10278 char * kwnames[] = {
10279 (char *) "owner",(char *) "id", NULL
10280 };
10281
10282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10283 if (obj0) {
10284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10285 if (!SWIG_IsOK(res1)) {
10286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10287 }
10288 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10289 }
10290 if (obj1) {
10291 ecode2 = SWIG_AsVal_int(obj1, &val2);
10292 if (!SWIG_IsOK(ecode2)) {
10293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10294 }
10295 arg2 = static_cast< int >(val2);
10296 }
10297 {
10298 if (!wxPyCheckForApp()) SWIG_fail;
10299 PyThreadState* __tstate = wxPyBeginAllowThreads();
10300 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10301 wxPyEndAllowThreads(__tstate);
10302 if (PyErr_Occurred()) SWIG_fail;
10303 }
10304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10305 return resultobj;
10306 fail:
10307 return NULL;
10308 }
10309
10310
10311 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10312 PyObject *resultobj = 0;
10313 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10314 void *argp1 = 0 ;
10315 int res1 = 0 ;
10316 PyObject *swig_obj[1] ;
10317
10318 if (!args) SWIG_fail;
10319 swig_obj[0] = args;
10320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10321 if (!SWIG_IsOK(res1)) {
10322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10323 }
10324 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10325 {
10326 PyThreadState* __tstate = wxPyBeginAllowThreads();
10327 delete arg1;
10328
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 resultobj = SWIG_Py_Void();
10333 return resultobj;
10334 fail:
10335 return NULL;
10336 }
10337
10338
10339 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10340 PyObject *resultobj = 0;
10341 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10342 PyObject *arg2 = (PyObject *) 0 ;
10343 PyObject *arg3 = (PyObject *) 0 ;
10344 int arg4 = (int) 1 ;
10345 void *argp1 = 0 ;
10346 int res1 = 0 ;
10347 int val4 ;
10348 int ecode4 = 0 ;
10349 PyObject * obj0 = 0 ;
10350 PyObject * obj1 = 0 ;
10351 PyObject * obj2 = 0 ;
10352 PyObject * obj3 = 0 ;
10353 char * kwnames[] = {
10354 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10355 };
10356
10357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10359 if (!SWIG_IsOK(res1)) {
10360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10361 }
10362 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10363 arg2 = obj1;
10364 arg3 = obj2;
10365 if (obj3) {
10366 ecode4 = SWIG_AsVal_int(obj3, &val4);
10367 if (!SWIG_IsOK(ecode4)) {
10368 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10369 }
10370 arg4 = static_cast< int >(val4);
10371 }
10372 {
10373 PyThreadState* __tstate = wxPyBeginAllowThreads();
10374 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 resultobj = SWIG_Py_Void();
10379 return resultobj;
10380 fail:
10381 return NULL;
10382 }
10383
10384
10385 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10386 PyObject *resultobj = 0;
10387 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10388 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10389 int arg3 = (int) wxID_ANY ;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 void *argp2 = 0 ;
10393 int res2 = 0 ;
10394 int val3 ;
10395 int ecode3 = 0 ;
10396 PyObject * obj0 = 0 ;
10397 PyObject * obj1 = 0 ;
10398 PyObject * obj2 = 0 ;
10399 char * kwnames[] = {
10400 (char *) "self",(char *) "owner",(char *) "id", NULL
10401 };
10402
10403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10405 if (!SWIG_IsOK(res1)) {
10406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10407 }
10408 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10409 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10410 if (!SWIG_IsOK(res2)) {
10411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10412 }
10413 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10414 if (obj2) {
10415 ecode3 = SWIG_AsVal_int(obj2, &val3);
10416 if (!SWIG_IsOK(ecode3)) {
10417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10418 }
10419 arg3 = static_cast< int >(val3);
10420 }
10421 {
10422 PyThreadState* __tstate = wxPyBeginAllowThreads();
10423 (arg1)->SetOwner(arg2,arg3);
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 resultobj = SWIG_Py_Void();
10428 return resultobj;
10429 fail:
10430 return NULL;
10431 }
10432
10433
10434 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10435 PyObject *resultobj = 0;
10436 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10437 wxEvtHandler *result = 0 ;
10438 void *argp1 = 0 ;
10439 int res1 = 0 ;
10440 PyObject *swig_obj[1] ;
10441
10442 if (!args) SWIG_fail;
10443 swig_obj[0] = args;
10444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10445 if (!SWIG_IsOK(res1)) {
10446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10447 }
10448 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (wxEvtHandler *)(arg1)->GetOwner();
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 {
10456 resultobj = wxPyMake_wxObject(result, 0);
10457 }
10458 return resultobj;
10459 fail:
10460 return NULL;
10461 }
10462
10463
10464 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10465 PyObject *resultobj = 0;
10466 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10467 int arg2 = (int) -1 ;
10468 bool arg3 = (bool) false ;
10469 bool result;
10470 void *argp1 = 0 ;
10471 int res1 = 0 ;
10472 int val2 ;
10473 int ecode2 = 0 ;
10474 bool val3 ;
10475 int ecode3 = 0 ;
10476 PyObject * obj0 = 0 ;
10477 PyObject * obj1 = 0 ;
10478 PyObject * obj2 = 0 ;
10479 char * kwnames[] = {
10480 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10481 };
10482
10483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10485 if (!SWIG_IsOK(res1)) {
10486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10487 }
10488 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10489 if (obj1) {
10490 ecode2 = SWIG_AsVal_int(obj1, &val2);
10491 if (!SWIG_IsOK(ecode2)) {
10492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10493 }
10494 arg2 = static_cast< int >(val2);
10495 }
10496 if (obj2) {
10497 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10498 if (!SWIG_IsOK(ecode3)) {
10499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10500 }
10501 arg3 = static_cast< bool >(val3);
10502 }
10503 {
10504 PyThreadState* __tstate = wxPyBeginAllowThreads();
10505 result = (bool)(arg1)->Start(arg2,arg3);
10506 wxPyEndAllowThreads(__tstate);
10507 if (PyErr_Occurred()) SWIG_fail;
10508 }
10509 {
10510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10511 }
10512 return resultobj;
10513 fail:
10514 return NULL;
10515 }
10516
10517
10518 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10519 PyObject *resultobj = 0;
10520 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10521 void *argp1 = 0 ;
10522 int res1 = 0 ;
10523 PyObject *swig_obj[1] ;
10524
10525 if (!args) SWIG_fail;
10526 swig_obj[0] = args;
10527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10528 if (!SWIG_IsOK(res1)) {
10529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10530 }
10531 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 (arg1)->Stop();
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 resultobj = SWIG_Py_Void();
10539 return resultobj;
10540 fail:
10541 return NULL;
10542 }
10543
10544
10545 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10546 PyObject *resultobj = 0;
10547 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10548 void *argp1 = 0 ;
10549 int res1 = 0 ;
10550 PyObject *swig_obj[1] ;
10551
10552 if (!args) SWIG_fail;
10553 swig_obj[0] = args;
10554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10555 if (!SWIG_IsOK(res1)) {
10556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10557 }
10558 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10559 {
10560 PyThreadState* __tstate = wxPyBeginAllowThreads();
10561 (arg1)->Notify();
10562 wxPyEndAllowThreads(__tstate);
10563 if (PyErr_Occurred()) SWIG_fail;
10564 }
10565 resultobj = SWIG_Py_Void();
10566 return resultobj;
10567 fail:
10568 return NULL;
10569 }
10570
10571
10572 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10573 PyObject *resultobj = 0;
10574 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10575 bool result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 PyObject *swig_obj[1] ;
10579
10580 if (!args) SWIG_fail;
10581 swig_obj[0] = args;
10582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10583 if (!SWIG_IsOK(res1)) {
10584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10585 }
10586 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10587 {
10588 PyThreadState* __tstate = wxPyBeginAllowThreads();
10589 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10590 wxPyEndAllowThreads(__tstate);
10591 if (PyErr_Occurred()) SWIG_fail;
10592 }
10593 {
10594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10595 }
10596 return resultobj;
10597 fail:
10598 return NULL;
10599 }
10600
10601
10602 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10603 PyObject *resultobj = 0;
10604 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10605 int result;
10606 void *argp1 = 0 ;
10607 int res1 = 0 ;
10608 PyObject *swig_obj[1] ;
10609
10610 if (!args) SWIG_fail;
10611 swig_obj[0] = args;
10612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10613 if (!SWIG_IsOK(res1)) {
10614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10615 }
10616 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10617 {
10618 PyThreadState* __tstate = wxPyBeginAllowThreads();
10619 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10620 wxPyEndAllowThreads(__tstate);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 resultobj = SWIG_From_int(static_cast< int >(result));
10624 return resultobj;
10625 fail:
10626 return NULL;
10627 }
10628
10629
10630 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10631 PyObject *resultobj = 0;
10632 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10633 int result;
10634 void *argp1 = 0 ;
10635 int res1 = 0 ;
10636 PyObject *swig_obj[1] ;
10637
10638 if (!args) SWIG_fail;
10639 swig_obj[0] = args;
10640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10641 if (!SWIG_IsOK(res1)) {
10642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10643 }
10644 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10645 {
10646 PyThreadState* __tstate = wxPyBeginAllowThreads();
10647 result = (int)((wxPyTimer const *)arg1)->GetId();
10648 wxPyEndAllowThreads(__tstate);
10649 if (PyErr_Occurred()) SWIG_fail;
10650 }
10651 resultobj = SWIG_From_int(static_cast< int >(result));
10652 return resultobj;
10653 fail:
10654 return NULL;
10655 }
10656
10657
10658 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10659 PyObject *resultobj = 0;
10660 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10661 bool result;
10662 void *argp1 = 0 ;
10663 int res1 = 0 ;
10664 PyObject *swig_obj[1] ;
10665
10666 if (!args) SWIG_fail;
10667 swig_obj[0] = args;
10668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10669 if (!SWIG_IsOK(res1)) {
10670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10671 }
10672 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 {
10680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10681 }
10682 return resultobj;
10683 fail:
10684 return NULL;
10685 }
10686
10687
10688 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10689 PyObject *obj;
10690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10691 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10692 return SWIG_Py_Void();
10693 }
10694
10695 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10696 return SWIG_Python_InitShadowInstance(args);
10697 }
10698
10699 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10700 PyObject *resultobj = 0;
10701 int arg1 = (int) 0 ;
10702 int arg2 = (int) 0 ;
10703 wxTimerEvent *result = 0 ;
10704 int val1 ;
10705 int ecode1 = 0 ;
10706 int val2 ;
10707 int ecode2 = 0 ;
10708 PyObject * obj0 = 0 ;
10709 PyObject * obj1 = 0 ;
10710 char * kwnames[] = {
10711 (char *) "timerid",(char *) "interval", NULL
10712 };
10713
10714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10715 if (obj0) {
10716 ecode1 = SWIG_AsVal_int(obj0, &val1);
10717 if (!SWIG_IsOK(ecode1)) {
10718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10719 }
10720 arg1 = static_cast< int >(val1);
10721 }
10722 if (obj1) {
10723 ecode2 = SWIG_AsVal_int(obj1, &val2);
10724 if (!SWIG_IsOK(ecode2)) {
10725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10726 }
10727 arg2 = static_cast< int >(val2);
10728 }
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10732 wxPyEndAllowThreads(__tstate);
10733 if (PyErr_Occurred()) SWIG_fail;
10734 }
10735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10736 return resultobj;
10737 fail:
10738 return NULL;
10739 }
10740
10741
10742 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10743 PyObject *resultobj = 0;
10744 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10745 int result;
10746 void *argp1 = 0 ;
10747 int res1 = 0 ;
10748 PyObject *swig_obj[1] ;
10749
10750 if (!args) SWIG_fail;
10751 swig_obj[0] = args;
10752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10753 if (!SWIG_IsOK(res1)) {
10754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10755 }
10756 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 resultobj = SWIG_From_int(static_cast< int >(result));
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10771 PyObject *obj;
10772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10773 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10774 return SWIG_Py_Void();
10775 }
10776
10777 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10778 return SWIG_Python_InitShadowInstance(args);
10779 }
10780
10781 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10782 PyObject *resultobj = 0;
10783 wxTimer *arg1 = 0 ;
10784 wxTimerRunner *result = 0 ;
10785 void *argp1 = 0 ;
10786 int res1 = 0 ;
10787
10788 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10790 if (!SWIG_IsOK(res1)) {
10791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10792 }
10793 if (!argp1) {
10794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10795 }
10796 arg1 = reinterpret_cast< wxTimer * >(argp1);
10797 {
10798 if (!wxPyCheckForApp()) SWIG_fail;
10799 PyThreadState* __tstate = wxPyBeginAllowThreads();
10800 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10805 return resultobj;
10806 fail:
10807 return NULL;
10808 }
10809
10810
10811 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10812 PyObject *resultobj = 0;
10813 wxTimer *arg1 = 0 ;
10814 int arg2 ;
10815 bool arg3 = (bool) false ;
10816 wxTimerRunner *result = 0 ;
10817 void *argp1 = 0 ;
10818 int res1 = 0 ;
10819 int val2 ;
10820 int ecode2 = 0 ;
10821 bool val3 ;
10822 int ecode3 = 0 ;
10823
10824 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10826 if (!SWIG_IsOK(res1)) {
10827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10828 }
10829 if (!argp1) {
10830 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10831 }
10832 arg1 = reinterpret_cast< wxTimer * >(argp1);
10833 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10834 if (!SWIG_IsOK(ecode2)) {
10835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10836 }
10837 arg2 = static_cast< int >(val2);
10838 if (swig_obj[2]) {
10839 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10840 if (!SWIG_IsOK(ecode3)) {
10841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10842 }
10843 arg3 = static_cast< bool >(val3);
10844 }
10845 {
10846 if (!wxPyCheckForApp()) SWIG_fail;
10847 PyThreadState* __tstate = wxPyBeginAllowThreads();
10848 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10849 wxPyEndAllowThreads(__tstate);
10850 if (PyErr_Occurred()) SWIG_fail;
10851 }
10852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10853 return resultobj;
10854 fail:
10855 return NULL;
10856 }
10857
10858
10859 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10860 int argc;
10861 PyObject *argv[4];
10862
10863 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10864 --argc;
10865 if (argc == 1) {
10866 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10867 }
10868 if ((argc >= 2) && (argc <= 3)) {
10869 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10870 }
10871
10872 fail:
10873 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10879 PyObject *resultobj = 0;
10880 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 PyObject *swig_obj[1] ;
10884
10885 if (!args) SWIG_fail;
10886 swig_obj[0] = args;
10887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10888 if (!SWIG_IsOK(res1)) {
10889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10890 }
10891 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 delete arg1;
10895
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_Py_Void();
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = 0;
10908 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10909 int arg2 ;
10910 bool arg3 = (bool) false ;
10911 void *argp1 = 0 ;
10912 int res1 = 0 ;
10913 int val2 ;
10914 int ecode2 = 0 ;
10915 bool val3 ;
10916 int ecode3 = 0 ;
10917 PyObject * obj0 = 0 ;
10918 PyObject * obj1 = 0 ;
10919 PyObject * obj2 = 0 ;
10920 char * kwnames[] = {
10921 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10922 };
10923
10924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10926 if (!SWIG_IsOK(res1)) {
10927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10928 }
10929 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10930 ecode2 = SWIG_AsVal_int(obj1, &val2);
10931 if (!SWIG_IsOK(ecode2)) {
10932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10933 }
10934 arg2 = static_cast< int >(val2);
10935 if (obj2) {
10936 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10937 if (!SWIG_IsOK(ecode3)) {
10938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10939 }
10940 arg3 = static_cast< bool >(val3);
10941 }
10942 {
10943 PyThreadState* __tstate = wxPyBeginAllowThreads();
10944 (arg1)->Start(arg2,arg3);
10945 wxPyEndAllowThreads(__tstate);
10946 if (PyErr_Occurred()) SWIG_fail;
10947 }
10948 resultobj = SWIG_Py_Void();
10949 return resultobj;
10950 fail:
10951 return NULL;
10952 }
10953
10954
10955 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10956 PyObject *obj;
10957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10958 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10959 return SWIG_Py_Void();
10960 }
10961
10962 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10963 return SWIG_Python_InitShadowInstance(args);
10964 }
10965
10966 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10967 PyObject *resultobj = 0;
10968 wxLog *result = 0 ;
10969
10970 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10971 {
10972 PyThreadState* __tstate = wxPyBeginAllowThreads();
10973 result = (wxLog *)new wxLog();
10974 wxPyEndAllowThreads(__tstate);
10975 if (PyErr_Occurred()) SWIG_fail;
10976 }
10977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10978 return resultobj;
10979 fail:
10980 return NULL;
10981 }
10982
10983
10984 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10985 PyObject *resultobj = 0;
10986 wxLog *arg1 = (wxLog *) 0 ;
10987 void *argp1 = 0 ;
10988 int res1 = 0 ;
10989 PyObject *swig_obj[1] ;
10990
10991 if (!args) SWIG_fail;
10992 swig_obj[0] = args;
10993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10994 if (!SWIG_IsOK(res1)) {
10995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10996 }
10997 arg1 = reinterpret_cast< wxLog * >(argp1);
10998 {
10999 PyThreadState* __tstate = wxPyBeginAllowThreads();
11000 delete arg1;
11001
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 resultobj = SWIG_Py_Void();
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11013 PyObject *resultobj = 0;
11014 bool result;
11015
11016 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11017 {
11018 PyThreadState* __tstate = wxPyBeginAllowThreads();
11019 result = (bool)wxLog::IsEnabled();
11020 wxPyEndAllowThreads(__tstate);
11021 if (PyErr_Occurred()) SWIG_fail;
11022 }
11023 {
11024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11025 }
11026 return resultobj;
11027 fail:
11028 return NULL;
11029 }
11030
11031
11032 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11033 PyObject *resultobj = 0;
11034 bool arg1 = (bool) true ;
11035 bool result;
11036 bool val1 ;
11037 int ecode1 = 0 ;
11038 PyObject * obj0 = 0 ;
11039 char * kwnames[] = {
11040 (char *) "doIt", NULL
11041 };
11042
11043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11044 if (obj0) {
11045 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11046 if (!SWIG_IsOK(ecode1)) {
11047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11048 }
11049 arg1 = static_cast< bool >(val1);
11050 }
11051 {
11052 PyThreadState* __tstate = wxPyBeginAllowThreads();
11053 result = (bool)wxLog::EnableLogging(arg1);
11054 wxPyEndAllowThreads(__tstate);
11055 if (PyErr_Occurred()) SWIG_fail;
11056 }
11057 {
11058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11059 }
11060 return resultobj;
11061 fail:
11062 return NULL;
11063 }
11064
11065
11066 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11067 PyObject *resultobj = 0;
11068 wxLogLevel arg1 ;
11069 wxChar *arg2 = (wxChar *) 0 ;
11070 time_t arg3 ;
11071 unsigned long val1 ;
11072 int ecode1 = 0 ;
11073 void *argp2 = 0 ;
11074 int res2 = 0 ;
11075 unsigned int val3 ;
11076 int ecode3 = 0 ;
11077 PyObject * obj0 = 0 ;
11078 PyObject * obj1 = 0 ;
11079 PyObject * obj2 = 0 ;
11080 char * kwnames[] = {
11081 (char *) "level",(char *) "szString",(char *) "t", NULL
11082 };
11083
11084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11085 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11086 if (!SWIG_IsOK(ecode1)) {
11087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11088 }
11089 arg1 = static_cast< wxLogLevel >(val1);
11090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11091 if (!SWIG_IsOK(res2)) {
11092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11093 }
11094 arg2 = reinterpret_cast< wxChar * >(argp2);
11095 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11096 if (!SWIG_IsOK(ecode3)) {
11097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11098 }
11099 arg3 = static_cast< time_t >(val3);
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11103 wxPyEndAllowThreads(__tstate);
11104 if (PyErr_Occurred()) SWIG_fail;
11105 }
11106 resultobj = SWIG_Py_Void();
11107 return resultobj;
11108 fail:
11109 return NULL;
11110 }
11111
11112
11113 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11114 PyObject *resultobj = 0;
11115 wxLog *arg1 = (wxLog *) 0 ;
11116 void *argp1 = 0 ;
11117 int res1 = 0 ;
11118 PyObject *swig_obj[1] ;
11119
11120 if (!args) SWIG_fail;
11121 swig_obj[0] = args;
11122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11123 if (!SWIG_IsOK(res1)) {
11124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11125 }
11126 arg1 = reinterpret_cast< wxLog * >(argp1);
11127 {
11128 PyThreadState* __tstate = wxPyBeginAllowThreads();
11129 (arg1)->Flush();
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 resultobj = SWIG_Py_Void();
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142
11143 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 wxLog::FlushActive();
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 resultobj = SWIG_Py_Void();
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11158 PyObject *resultobj = 0;
11159 wxLog *result = 0 ;
11160
11161 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11162 {
11163 PyThreadState* __tstate = wxPyBeginAllowThreads();
11164 result = (wxLog *)wxLog::GetActiveTarget();
11165 wxPyEndAllowThreads(__tstate);
11166 if (PyErr_Occurred()) SWIG_fail;
11167 }
11168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11176 PyObject *resultobj = 0;
11177 wxLog *arg1 = (wxLog *) 0 ;
11178 wxLog *result = 0 ;
11179 int res1 = 0 ;
11180 PyObject * obj0 = 0 ;
11181 char * kwnames[] = {
11182 (char *) "pLogger", NULL
11183 };
11184
11185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11186 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11187 if (!SWIG_IsOK(res1)) {
11188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11189 }
11190 {
11191 PyThreadState* __tstate = wxPyBeginAllowThreads();
11192 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11193 wxPyEndAllowThreads(__tstate);
11194 if (PyErr_Occurred()) SWIG_fail;
11195 }
11196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11204 PyObject *resultobj = 0;
11205
11206 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11207 {
11208 PyThreadState* __tstate = wxPyBeginAllowThreads();
11209 wxLog::Suspend();
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 resultobj = SWIG_Py_Void();
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11221 PyObject *resultobj = 0;
11222
11223 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11224 {
11225 PyThreadState* __tstate = wxPyBeginAllowThreads();
11226 wxLog::Resume();
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 resultobj = SWIG_Py_Void();
11231 return resultobj;
11232 fail:
11233 return NULL;
11234 }
11235
11236
11237 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11238 PyObject *resultobj = 0;
11239 bool arg1 = (bool) true ;
11240 bool val1 ;
11241 int ecode1 = 0 ;
11242 PyObject * obj0 = 0 ;
11243 char * kwnames[] = {
11244 (char *) "bVerbose", NULL
11245 };
11246
11247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11248 if (obj0) {
11249 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11250 if (!SWIG_IsOK(ecode1)) {
11251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11252 }
11253 arg1 = static_cast< bool >(val1);
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 wxLog::SetVerbose(arg1);
11258 wxPyEndAllowThreads(__tstate);
11259 if (PyErr_Occurred()) SWIG_fail;
11260 }
11261 resultobj = SWIG_Py_Void();
11262 return resultobj;
11263 fail:
11264 return NULL;
11265 }
11266
11267
11268 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11269 PyObject *resultobj = 0;
11270 wxLogLevel arg1 ;
11271 unsigned long val1 ;
11272 int ecode1 = 0 ;
11273 PyObject * obj0 = 0 ;
11274 char * kwnames[] = {
11275 (char *) "logLevel", NULL
11276 };
11277
11278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11279 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11280 if (!SWIG_IsOK(ecode1)) {
11281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11282 }
11283 arg1 = static_cast< wxLogLevel >(val1);
11284 {
11285 PyThreadState* __tstate = wxPyBeginAllowThreads();
11286 wxLog::SetLogLevel(arg1);
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 resultobj = SWIG_Py_Void();
11291 return resultobj;
11292 fail:
11293 return NULL;
11294 }
11295
11296
11297 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11298 PyObject *resultobj = 0;
11299
11300 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 wxLog::DontCreateOnDemand();
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 resultobj = SWIG_Py_Void();
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj = 0;
11316 wxTraceMask arg1 ;
11317 unsigned long val1 ;
11318 int ecode1 = 0 ;
11319 PyObject * obj0 = 0 ;
11320 char * kwnames[] = {
11321 (char *) "ulMask", NULL
11322 };
11323
11324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11325 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11326 if (!SWIG_IsOK(ecode1)) {
11327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11328 }
11329 arg1 = static_cast< wxTraceMask >(val1);
11330 {
11331 PyThreadState* __tstate = wxPyBeginAllowThreads();
11332 wxLog::SetTraceMask(arg1);
11333 wxPyEndAllowThreads(__tstate);
11334 if (PyErr_Occurred()) SWIG_fail;
11335 }
11336 resultobj = SWIG_Py_Void();
11337 return resultobj;
11338 fail:
11339 return NULL;
11340 }
11341
11342
11343 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11344 PyObject *resultobj = 0;
11345 wxString *arg1 = 0 ;
11346 bool temp1 = false ;
11347 PyObject * obj0 = 0 ;
11348 char * kwnames[] = {
11349 (char *) "str", NULL
11350 };
11351
11352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11353 {
11354 arg1 = wxString_in_helper(obj0);
11355 if (arg1 == NULL) SWIG_fail;
11356 temp1 = true;
11357 }
11358 {
11359 PyThreadState* __tstate = wxPyBeginAllowThreads();
11360 wxLog::AddTraceMask((wxString const &)*arg1);
11361 wxPyEndAllowThreads(__tstate);
11362 if (PyErr_Occurred()) SWIG_fail;
11363 }
11364 resultobj = SWIG_Py_Void();
11365 {
11366 if (temp1)
11367 delete arg1;
11368 }
11369 return resultobj;
11370 fail:
11371 {
11372 if (temp1)
11373 delete arg1;
11374 }
11375 return NULL;
11376 }
11377
11378
11379 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11380 PyObject *resultobj = 0;
11381 wxString *arg1 = 0 ;
11382 bool temp1 = false ;
11383 PyObject * obj0 = 0 ;
11384 char * kwnames[] = {
11385 (char *) "str", NULL
11386 };
11387
11388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11389 {
11390 arg1 = wxString_in_helper(obj0);
11391 if (arg1 == NULL) SWIG_fail;
11392 temp1 = true;
11393 }
11394 {
11395 PyThreadState* __tstate = wxPyBeginAllowThreads();
11396 wxLog::RemoveTraceMask((wxString const &)*arg1);
11397 wxPyEndAllowThreads(__tstate);
11398 if (PyErr_Occurred()) SWIG_fail;
11399 }
11400 resultobj = SWIG_Py_Void();
11401 {
11402 if (temp1)
11403 delete arg1;
11404 }
11405 return resultobj;
11406 fail:
11407 {
11408 if (temp1)
11409 delete arg1;
11410 }
11411 return NULL;
11412 }
11413
11414
11415 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11416 PyObject *resultobj = 0;
11417
11418 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11419 {
11420 PyThreadState* __tstate = wxPyBeginAllowThreads();
11421 wxLog::ClearTraceMasks();
11422 wxPyEndAllowThreads(__tstate);
11423 if (PyErr_Occurred()) SWIG_fail;
11424 }
11425 resultobj = SWIG_Py_Void();
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11433 PyObject *resultobj = 0;
11434 wxArrayString *result = 0 ;
11435
11436 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11437 {
11438 PyThreadState* __tstate = wxPyBeginAllowThreads();
11439 {
11440 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11441 result = (wxArrayString *) &_result_ref;
11442 }
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 {
11447 resultobj = wxArrayString2PyList_helper(*result);
11448 }
11449 return resultobj;
11450 fail:
11451 return NULL;
11452 }
11453
11454
11455 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11456 PyObject *resultobj = 0;
11457 wxChar *arg1 = (wxChar *) 0 ;
11458 void *argp1 = 0 ;
11459 int res1 = 0 ;
11460 PyObject * obj0 = 0 ;
11461 char * kwnames[] = {
11462 (char *) "ts", NULL
11463 };
11464
11465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11467 if (!SWIG_IsOK(res1)) {
11468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11469 }
11470 arg1 = reinterpret_cast< wxChar * >(argp1);
11471 {
11472 PyThreadState* __tstate = wxPyBeginAllowThreads();
11473 wxLog::SetTimestamp((wxChar const *)arg1);
11474 wxPyEndAllowThreads(__tstate);
11475 if (PyErr_Occurred()) SWIG_fail;
11476 }
11477 resultobj = SWIG_Py_Void();
11478 return resultobj;
11479 fail:
11480 return NULL;
11481 }
11482
11483
11484 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11485 PyObject *resultobj = 0;
11486 bool result;
11487
11488 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11489 {
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (bool)wxLog::GetVerbose();
11492 wxPyEndAllowThreads(__tstate);
11493 if (PyErr_Occurred()) SWIG_fail;
11494 }
11495 {
11496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11497 }
11498 return resultobj;
11499 fail:
11500 return NULL;
11501 }
11502
11503
11504 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11505 PyObject *resultobj = 0;
11506 wxTraceMask result;
11507
11508 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11509 {
11510 PyThreadState* __tstate = wxPyBeginAllowThreads();
11511 result = (wxTraceMask)wxLog::GetTraceMask();
11512 wxPyEndAllowThreads(__tstate);
11513 if (PyErr_Occurred()) SWIG_fail;
11514 }
11515 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11516 return resultobj;
11517 fail:
11518 return NULL;
11519 }
11520
11521
11522 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11523 PyObject *resultobj = 0;
11524 wxChar *arg1 = (wxChar *) 0 ;
11525 bool result;
11526 void *argp1 = 0 ;
11527 int res1 = 0 ;
11528 PyObject * obj0 = 0 ;
11529 char * kwnames[] = {
11530 (char *) "mask", NULL
11531 };
11532
11533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11535 if (!SWIG_IsOK(res1)) {
11536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11537 }
11538 arg1 = reinterpret_cast< wxChar * >(argp1);
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11542 wxPyEndAllowThreads(__tstate);
11543 if (PyErr_Occurred()) SWIG_fail;
11544 }
11545 {
11546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11547 }
11548 return resultobj;
11549 fail:
11550 return NULL;
11551 }
11552
11553
11554 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11555 PyObject *resultobj = 0;
11556 wxLogLevel result;
11557
11558 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (wxLogLevel)wxLog::GetLogLevel();
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11566 return resultobj;
11567 fail:
11568 return NULL;
11569 }
11570
11571
11572 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11573 PyObject *resultobj = 0;
11574 wxChar *result = 0 ;
11575
11576 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11577 {
11578 PyThreadState* __tstate = wxPyBeginAllowThreads();
11579 result = (wxChar *)wxLog::GetTimestamp();
11580 wxPyEndAllowThreads(__tstate);
11581 if (PyErr_Occurred()) SWIG_fail;
11582 }
11583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11584 return resultobj;
11585 fail:
11586 return NULL;
11587 }
11588
11589
11590 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11591 PyObject *resultobj = 0;
11592 wxString result;
11593
11594 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = wxLog_TimeStamp();
11598 wxPyEndAllowThreads(__tstate);
11599 if (PyErr_Occurred()) SWIG_fail;
11600 }
11601 {
11602 #if wxUSE_UNICODE
11603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11604 #else
11605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11606 #endif
11607 }
11608 return resultobj;
11609 fail:
11610 return NULL;
11611 }
11612
11613
11614 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11615 PyObject *resultobj = 0;
11616 wxLog *arg1 = (wxLog *) 0 ;
11617 void *argp1 = 0 ;
11618 int res1 = 0 ;
11619 PyObject *swig_obj[1] ;
11620
11621 if (!args) SWIG_fail;
11622 swig_obj[0] = args;
11623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11624 if (!SWIG_IsOK(res1)) {
11625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11626 }
11627 arg1 = reinterpret_cast< wxLog * >(argp1);
11628 {
11629 PyThreadState* __tstate = wxPyBeginAllowThreads();
11630 wxLog_Destroy(arg1);
11631 wxPyEndAllowThreads(__tstate);
11632 if (PyErr_Occurred()) SWIG_fail;
11633 }
11634 resultobj = SWIG_Py_Void();
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11642 PyObject *obj;
11643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11644 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11645 return SWIG_Py_Void();
11646 }
11647
11648 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11649 return SWIG_Python_InitShadowInstance(args);
11650 }
11651
11652 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11653 PyObject *resultobj = 0;
11654 wxLogStderr *result = 0 ;
11655
11656 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = (wxLogStderr *)new wxLogStderr();
11660 wxPyEndAllowThreads(__tstate);
11661 if (PyErr_Occurred()) SWIG_fail;
11662 }
11663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11671 PyObject *obj;
11672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11673 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11674 return SWIG_Py_Void();
11675 }
11676
11677 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11678 return SWIG_Python_InitShadowInstance(args);
11679 }
11680
11681 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11682 PyObject *resultobj = 0;
11683 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11684 wxLogTextCtrl *result = 0 ;
11685 void *argp1 = 0 ;
11686 int res1 = 0 ;
11687 PyObject * obj0 = 0 ;
11688 char * kwnames[] = {
11689 (char *) "pTextCtrl", NULL
11690 };
11691
11692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11696 }
11697 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11698 {
11699 PyThreadState* __tstate = wxPyBeginAllowThreads();
11700 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11701 wxPyEndAllowThreads(__tstate);
11702 if (PyErr_Occurred()) SWIG_fail;
11703 }
11704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11705 return resultobj;
11706 fail:
11707 return NULL;
11708 }
11709
11710
11711 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11712 PyObject *obj;
11713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11714 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11715 return SWIG_Py_Void();
11716 }
11717
11718 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 return SWIG_Python_InitShadowInstance(args);
11720 }
11721
11722 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxLogGui *result = 0 ;
11725
11726 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (wxLogGui *)new wxLogGui();
11730 wxPyEndAllowThreads(__tstate);
11731 if (PyErr_Occurred()) SWIG_fail;
11732 }
11733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11734 return resultobj;
11735 fail:
11736 return NULL;
11737 }
11738
11739
11740 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11741 PyObject *obj;
11742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11743 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11744 return SWIG_Py_Void();
11745 }
11746
11747 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11748 return SWIG_Python_InitShadowInstance(args);
11749 }
11750
11751 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11752 PyObject *resultobj = 0;
11753 wxFrame *arg1 = (wxFrame *) 0 ;
11754 wxString *arg2 = 0 ;
11755 bool arg3 = (bool) true ;
11756 bool arg4 = (bool) true ;
11757 wxLogWindow *result = 0 ;
11758 void *argp1 = 0 ;
11759 int res1 = 0 ;
11760 bool temp2 = false ;
11761 bool val3 ;
11762 int ecode3 = 0 ;
11763 bool val4 ;
11764 int ecode4 = 0 ;
11765 PyObject * obj0 = 0 ;
11766 PyObject * obj1 = 0 ;
11767 PyObject * obj2 = 0 ;
11768 PyObject * obj3 = 0 ;
11769 char * kwnames[] = {
11770 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11771 };
11772
11773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11775 if (!SWIG_IsOK(res1)) {
11776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11777 }
11778 arg1 = reinterpret_cast< wxFrame * >(argp1);
11779 {
11780 arg2 = wxString_in_helper(obj1);
11781 if (arg2 == NULL) SWIG_fail;
11782 temp2 = true;
11783 }
11784 if (obj2) {
11785 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11786 if (!SWIG_IsOK(ecode3)) {
11787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11788 }
11789 arg3 = static_cast< bool >(val3);
11790 }
11791 if (obj3) {
11792 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11793 if (!SWIG_IsOK(ecode4)) {
11794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11795 }
11796 arg4 = static_cast< bool >(val4);
11797 }
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11801 wxPyEndAllowThreads(__tstate);
11802 if (PyErr_Occurred()) SWIG_fail;
11803 }
11804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11805 {
11806 if (temp2)
11807 delete arg2;
11808 }
11809 return resultobj;
11810 fail:
11811 {
11812 if (temp2)
11813 delete arg2;
11814 }
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11820 PyObject *resultobj = 0;
11821 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11822 bool arg2 = (bool) true ;
11823 void *argp1 = 0 ;
11824 int res1 = 0 ;
11825 bool val2 ;
11826 int ecode2 = 0 ;
11827 PyObject * obj0 = 0 ;
11828 PyObject * obj1 = 0 ;
11829 char * kwnames[] = {
11830 (char *) "self",(char *) "bShow", NULL
11831 };
11832
11833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11835 if (!SWIG_IsOK(res1)) {
11836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11837 }
11838 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11839 if (obj1) {
11840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11841 if (!SWIG_IsOK(ecode2)) {
11842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11843 }
11844 arg2 = static_cast< bool >(val2);
11845 }
11846 {
11847 PyThreadState* __tstate = wxPyBeginAllowThreads();
11848 (arg1)->Show(arg2);
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 resultobj = SWIG_Py_Void();
11853 return resultobj;
11854 fail:
11855 return NULL;
11856 }
11857
11858
11859 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11860 PyObject *resultobj = 0;
11861 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11862 wxFrame *result = 0 ;
11863 void *argp1 = 0 ;
11864 int res1 = 0 ;
11865 PyObject *swig_obj[1] ;
11866
11867 if (!args) SWIG_fail;
11868 swig_obj[0] = args;
11869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11870 if (!SWIG_IsOK(res1)) {
11871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11872 }
11873 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11874 {
11875 PyThreadState* __tstate = wxPyBeginAllowThreads();
11876 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11877 wxPyEndAllowThreads(__tstate);
11878 if (PyErr_Occurred()) SWIG_fail;
11879 }
11880 {
11881 resultobj = wxPyMake_wxObject(result, (bool)0);
11882 }
11883 return resultobj;
11884 fail:
11885 return NULL;
11886 }
11887
11888
11889 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11890 PyObject *resultobj = 0;
11891 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11892 wxLog *result = 0 ;
11893 void *argp1 = 0 ;
11894 int res1 = 0 ;
11895 PyObject *swig_obj[1] ;
11896
11897 if (!args) SWIG_fail;
11898 swig_obj[0] = args;
11899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11900 if (!SWIG_IsOK(res1)) {
11901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11902 }
11903 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11904 {
11905 PyThreadState* __tstate = wxPyBeginAllowThreads();
11906 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11911 return resultobj;
11912 fail:
11913 return NULL;
11914 }
11915
11916
11917 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11918 PyObject *resultobj = 0;
11919 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11920 bool result;
11921 void *argp1 = 0 ;
11922 int res1 = 0 ;
11923 PyObject *swig_obj[1] ;
11924
11925 if (!args) SWIG_fail;
11926 swig_obj[0] = args;
11927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11928 if (!SWIG_IsOK(res1)) {
11929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11930 }
11931 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11932 {
11933 PyThreadState* __tstate = wxPyBeginAllowThreads();
11934 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11935 wxPyEndAllowThreads(__tstate);
11936 if (PyErr_Occurred()) SWIG_fail;
11937 }
11938 {
11939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11940 }
11941 return resultobj;
11942 fail:
11943 return NULL;
11944 }
11945
11946
11947 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj = 0;
11949 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11950 bool arg2 ;
11951 void *argp1 = 0 ;
11952 int res1 = 0 ;
11953 bool val2 ;
11954 int ecode2 = 0 ;
11955 PyObject * obj0 = 0 ;
11956 PyObject * obj1 = 0 ;
11957 char * kwnames[] = {
11958 (char *) "self",(char *) "bDoPass", NULL
11959 };
11960
11961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11963 if (!SWIG_IsOK(res1)) {
11964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11965 }
11966 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11967 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11968 if (!SWIG_IsOK(ecode2)) {
11969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11970 }
11971 arg2 = static_cast< bool >(val2);
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 (arg1)->PassMessages(arg2);
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 resultobj = SWIG_Py_Void();
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11986 PyObject *obj;
11987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11988 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11989 return SWIG_Py_Void();
11990 }
11991
11992 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11993 return SWIG_Python_InitShadowInstance(args);
11994 }
11995
11996 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11997 PyObject *resultobj = 0;
11998 wxLog *arg1 = (wxLog *) 0 ;
11999 wxLogChain *result = 0 ;
12000 void *argp1 = 0 ;
12001 int res1 = 0 ;
12002 PyObject * obj0 = 0 ;
12003 char * kwnames[] = {
12004 (char *) "logger", NULL
12005 };
12006
12007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12009 if (!SWIG_IsOK(res1)) {
12010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12011 }
12012 arg1 = reinterpret_cast< wxLog * >(argp1);
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (wxLogChain *)new wxLogChain(arg1);
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12020 return resultobj;
12021 fail:
12022 return NULL;
12023 }
12024
12025
12026 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12027 PyObject *resultobj = 0;
12028 wxLogChain *arg1 = (wxLogChain *) 0 ;
12029 wxLog *arg2 = (wxLog *) 0 ;
12030 void *argp1 = 0 ;
12031 int res1 = 0 ;
12032 void *argp2 = 0 ;
12033 int res2 = 0 ;
12034 PyObject * obj0 = 0 ;
12035 PyObject * obj1 = 0 ;
12036 char * kwnames[] = {
12037 (char *) "self",(char *) "logger", NULL
12038 };
12039
12040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12042 if (!SWIG_IsOK(res1)) {
12043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12044 }
12045 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12047 if (!SWIG_IsOK(res2)) {
12048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12049 }
12050 arg2 = reinterpret_cast< wxLog * >(argp2);
12051 {
12052 PyThreadState* __tstate = wxPyBeginAllowThreads();
12053 (arg1)->SetLog(arg2);
12054 wxPyEndAllowThreads(__tstate);
12055 if (PyErr_Occurred()) SWIG_fail;
12056 }
12057 resultobj = SWIG_Py_Void();
12058 return resultobj;
12059 fail:
12060 return NULL;
12061 }
12062
12063
12064 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12065 PyObject *resultobj = 0;
12066 wxLogChain *arg1 = (wxLogChain *) 0 ;
12067 bool arg2 ;
12068 void *argp1 = 0 ;
12069 int res1 = 0 ;
12070 bool val2 ;
12071 int ecode2 = 0 ;
12072 PyObject * obj0 = 0 ;
12073 PyObject * obj1 = 0 ;
12074 char * kwnames[] = {
12075 (char *) "self",(char *) "bDoPass", NULL
12076 };
12077
12078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12080 if (!SWIG_IsOK(res1)) {
12081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12082 }
12083 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12084 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12085 if (!SWIG_IsOK(ecode2)) {
12086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12087 }
12088 arg2 = static_cast< bool >(val2);
12089 {
12090 PyThreadState* __tstate = wxPyBeginAllowThreads();
12091 (arg1)->PassMessages(arg2);
12092 wxPyEndAllowThreads(__tstate);
12093 if (PyErr_Occurred()) SWIG_fail;
12094 }
12095 resultobj = SWIG_Py_Void();
12096 return resultobj;
12097 fail:
12098 return NULL;
12099 }
12100
12101
12102 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12103 PyObject *resultobj = 0;
12104 wxLogChain *arg1 = (wxLogChain *) 0 ;
12105 bool result;
12106 void *argp1 = 0 ;
12107 int res1 = 0 ;
12108 PyObject *swig_obj[1] ;
12109
12110 if (!args) SWIG_fail;
12111 swig_obj[0] = args;
12112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12113 if (!SWIG_IsOK(res1)) {
12114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12115 }
12116 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12117 {
12118 PyThreadState* __tstate = wxPyBeginAllowThreads();
12119 result = (bool)(arg1)->IsPassingMessages();
12120 wxPyEndAllowThreads(__tstate);
12121 if (PyErr_Occurred()) SWIG_fail;
12122 }
12123 {
12124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12125 }
12126 return resultobj;
12127 fail:
12128 return NULL;
12129 }
12130
12131
12132 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12133 PyObject *resultobj = 0;
12134 wxLogChain *arg1 = (wxLogChain *) 0 ;
12135 wxLog *result = 0 ;
12136 void *argp1 = 0 ;
12137 int res1 = 0 ;
12138 PyObject *swig_obj[1] ;
12139
12140 if (!args) SWIG_fail;
12141 swig_obj[0] = args;
12142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12143 if (!SWIG_IsOK(res1)) {
12144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12145 }
12146 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12147 {
12148 PyThreadState* __tstate = wxPyBeginAllowThreads();
12149 result = (wxLog *)(arg1)->GetOldLog();
12150 wxPyEndAllowThreads(__tstate);
12151 if (PyErr_Occurred()) SWIG_fail;
12152 }
12153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12154 return resultobj;
12155 fail:
12156 return NULL;
12157 }
12158
12159
12160 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12161 PyObject *obj;
12162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12163 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12164 return SWIG_Py_Void();
12165 }
12166
12167 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12168 return SWIG_Python_InitShadowInstance(args);
12169 }
12170
12171 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *resultobj = 0;
12173 wxLogBuffer *result = 0 ;
12174
12175 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12176 {
12177 PyThreadState* __tstate = wxPyBeginAllowThreads();
12178 result = (wxLogBuffer *)new wxLogBuffer();
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12190 PyObject *resultobj = 0;
12191 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12192 wxString *result = 0 ;
12193 void *argp1 = 0 ;
12194 int res1 = 0 ;
12195 PyObject *swig_obj[1] ;
12196
12197 if (!args) SWIG_fail;
12198 swig_obj[0] = args;
12199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12200 if (!SWIG_IsOK(res1)) {
12201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12202 }
12203 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12204 {
12205 PyThreadState* __tstate = wxPyBeginAllowThreads();
12206 {
12207 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12208 result = (wxString *) &_result_ref;
12209 }
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 {
12214 #if wxUSE_UNICODE
12215 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12216 #else
12217 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12218 #endif
12219 }
12220 return resultobj;
12221 fail:
12222 return NULL;
12223 }
12224
12225
12226 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12227 PyObject *obj;
12228 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12229 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12230 return SWIG_Py_Void();
12231 }
12232
12233 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12234 return SWIG_Python_InitShadowInstance(args);
12235 }
12236
12237 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12238 PyObject *resultobj = 0;
12239 unsigned long result;
12240
12241 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12242 {
12243 PyThreadState* __tstate = wxPyBeginAllowThreads();
12244 result = (unsigned long)wxSysErrorCode();
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj = 0;
12257 unsigned long arg1 = (unsigned long) 0 ;
12258 wxString result;
12259 unsigned long val1 ;
12260 int ecode1 = 0 ;
12261 PyObject * obj0 = 0 ;
12262 char * kwnames[] = {
12263 (char *) "nErrCode", NULL
12264 };
12265
12266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12267 if (obj0) {
12268 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12269 if (!SWIG_IsOK(ecode1)) {
12270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12271 }
12272 arg1 = static_cast< unsigned long >(val1);
12273 }
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = wxSysErrorMsg(arg1);
12277 wxPyEndAllowThreads(__tstate);
12278 if (PyErr_Occurred()) SWIG_fail;
12279 }
12280 {
12281 #if wxUSE_UNICODE
12282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12283 #else
12284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12285 #endif
12286 }
12287 return resultobj;
12288 fail:
12289 return NULL;
12290 }
12291
12292
12293 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12294 PyObject *resultobj = 0;
12295 wxString *arg1 = 0 ;
12296 bool temp1 = false ;
12297 PyObject * obj0 = 0 ;
12298 char * kwnames[] = {
12299 (char *) "msg", NULL
12300 };
12301
12302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12303 {
12304 arg1 = wxString_in_helper(obj0);
12305 if (arg1 == NULL) SWIG_fail;
12306 temp1 = true;
12307 }
12308 {
12309 PyThreadState* __tstate = wxPyBeginAllowThreads();
12310 wxPyLogFatalError((wxString const &)*arg1);
12311 wxPyEndAllowThreads(__tstate);
12312 if (PyErr_Occurred()) SWIG_fail;
12313 }
12314 resultobj = SWIG_Py_Void();
12315 {
12316 if (temp1)
12317 delete arg1;
12318 }
12319 return resultobj;
12320 fail:
12321 {
12322 if (temp1)
12323 delete arg1;
12324 }
12325 return NULL;
12326 }
12327
12328
12329 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj = 0;
12331 wxString *arg1 = 0 ;
12332 bool temp1 = false ;
12333 PyObject * obj0 = 0 ;
12334 char * kwnames[] = {
12335 (char *) "msg", NULL
12336 };
12337
12338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12339 {
12340 arg1 = wxString_in_helper(obj0);
12341 if (arg1 == NULL) SWIG_fail;
12342 temp1 = true;
12343 }
12344 {
12345 PyThreadState* __tstate = wxPyBeginAllowThreads();
12346 wxPyLogError((wxString const &)*arg1);
12347 wxPyEndAllowThreads(__tstate);
12348 if (PyErr_Occurred()) SWIG_fail;
12349 }
12350 resultobj = SWIG_Py_Void();
12351 {
12352 if (temp1)
12353 delete arg1;
12354 }
12355 return resultobj;
12356 fail:
12357 {
12358 if (temp1)
12359 delete arg1;
12360 }
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj = 0;
12367 wxString *arg1 = 0 ;
12368 bool temp1 = false ;
12369 PyObject * obj0 = 0 ;
12370 char * kwnames[] = {
12371 (char *) "msg", NULL
12372 };
12373
12374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12375 {
12376 arg1 = wxString_in_helper(obj0);
12377 if (arg1 == NULL) SWIG_fail;
12378 temp1 = true;
12379 }
12380 {
12381 PyThreadState* __tstate = wxPyBeginAllowThreads();
12382 wxPyLogWarning((wxString const &)*arg1);
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 resultobj = SWIG_Py_Void();
12387 {
12388 if (temp1)
12389 delete arg1;
12390 }
12391 return resultobj;
12392 fail:
12393 {
12394 if (temp1)
12395 delete arg1;
12396 }
12397 return NULL;
12398 }
12399
12400
12401 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12402 PyObject *resultobj = 0;
12403 wxString *arg1 = 0 ;
12404 bool temp1 = false ;
12405 PyObject * obj0 = 0 ;
12406 char * kwnames[] = {
12407 (char *) "msg", NULL
12408 };
12409
12410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12411 {
12412 arg1 = wxString_in_helper(obj0);
12413 if (arg1 == NULL) SWIG_fail;
12414 temp1 = true;
12415 }
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 wxPyLogMessage((wxString const &)*arg1);
12419 wxPyEndAllowThreads(__tstate);
12420 if (PyErr_Occurred()) SWIG_fail;
12421 }
12422 resultobj = SWIG_Py_Void();
12423 {
12424 if (temp1)
12425 delete arg1;
12426 }
12427 return resultobj;
12428 fail:
12429 {
12430 if (temp1)
12431 delete arg1;
12432 }
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12438 PyObject *resultobj = 0;
12439 wxString *arg1 = 0 ;
12440 bool temp1 = false ;
12441 PyObject * obj0 = 0 ;
12442 char * kwnames[] = {
12443 (char *) "msg", NULL
12444 };
12445
12446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12447 {
12448 arg1 = wxString_in_helper(obj0);
12449 if (arg1 == NULL) SWIG_fail;
12450 temp1 = true;
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 wxPyLogInfo((wxString const &)*arg1);
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 resultobj = SWIG_Py_Void();
12459 {
12460 if (temp1)
12461 delete arg1;
12462 }
12463 return resultobj;
12464 fail:
12465 {
12466 if (temp1)
12467 delete arg1;
12468 }
12469 return NULL;
12470 }
12471
12472
12473 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12474 PyObject *resultobj = 0;
12475 wxString *arg1 = 0 ;
12476 bool temp1 = false ;
12477 PyObject * obj0 = 0 ;
12478 char * kwnames[] = {
12479 (char *) "msg", NULL
12480 };
12481
12482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12483 {
12484 arg1 = wxString_in_helper(obj0);
12485 if (arg1 == NULL) SWIG_fail;
12486 temp1 = true;
12487 }
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 wxPyLogDebug((wxString const &)*arg1);
12491 wxPyEndAllowThreads(__tstate);
12492 if (PyErr_Occurred()) SWIG_fail;
12493 }
12494 resultobj = SWIG_Py_Void();
12495 {
12496 if (temp1)
12497 delete arg1;
12498 }
12499 return resultobj;
12500 fail:
12501 {
12502 if (temp1)
12503 delete arg1;
12504 }
12505 return NULL;
12506 }
12507
12508
12509 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12510 PyObject *resultobj = 0;
12511 wxString *arg1 = 0 ;
12512 bool temp1 = false ;
12513 PyObject * obj0 = 0 ;
12514 char * kwnames[] = {
12515 (char *) "msg", NULL
12516 };
12517
12518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12519 {
12520 arg1 = wxString_in_helper(obj0);
12521 if (arg1 == NULL) SWIG_fail;
12522 temp1 = true;
12523 }
12524 {
12525 PyThreadState* __tstate = wxPyBeginAllowThreads();
12526 wxPyLogVerbose((wxString const &)*arg1);
12527 wxPyEndAllowThreads(__tstate);
12528 if (PyErr_Occurred()) SWIG_fail;
12529 }
12530 resultobj = SWIG_Py_Void();
12531 {
12532 if (temp1)
12533 delete arg1;
12534 }
12535 return resultobj;
12536 fail:
12537 {
12538 if (temp1)
12539 delete arg1;
12540 }
12541 return NULL;
12542 }
12543
12544
12545 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12546 PyObject *resultobj = 0;
12547 wxString *arg1 = 0 ;
12548 bool temp1 = false ;
12549 PyObject * obj0 = 0 ;
12550 char * kwnames[] = {
12551 (char *) "msg", NULL
12552 };
12553
12554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12555 {
12556 arg1 = wxString_in_helper(obj0);
12557 if (arg1 == NULL) SWIG_fail;
12558 temp1 = true;
12559 }
12560 {
12561 PyThreadState* __tstate = wxPyBeginAllowThreads();
12562 wxPyLogStatus((wxString const &)*arg1);
12563 wxPyEndAllowThreads(__tstate);
12564 if (PyErr_Occurred()) SWIG_fail;
12565 }
12566 resultobj = SWIG_Py_Void();
12567 {
12568 if (temp1)
12569 delete arg1;
12570 }
12571 return resultobj;
12572 fail:
12573 {
12574 if (temp1)
12575 delete arg1;
12576 }
12577 return NULL;
12578 }
12579
12580
12581 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj = 0;
12583 wxFrame *arg1 = (wxFrame *) 0 ;
12584 wxString *arg2 = 0 ;
12585 void *argp1 = 0 ;
12586 int res1 = 0 ;
12587 bool temp2 = false ;
12588 PyObject * obj0 = 0 ;
12589 PyObject * obj1 = 0 ;
12590 char * kwnames[] = {
12591 (char *) "pFrame",(char *) "msg", NULL
12592 };
12593
12594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12596 if (!SWIG_IsOK(res1)) {
12597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12598 }
12599 arg1 = reinterpret_cast< wxFrame * >(argp1);
12600 {
12601 arg2 = wxString_in_helper(obj1);
12602 if (arg2 == NULL) SWIG_fail;
12603 temp2 = true;
12604 }
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 resultobj = SWIG_Py_Void();
12612 {
12613 if (temp2)
12614 delete arg2;
12615 }
12616 return resultobj;
12617 fail:
12618 {
12619 if (temp2)
12620 delete arg2;
12621 }
12622 return NULL;
12623 }
12624
12625
12626 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj = 0;
12628 wxString *arg1 = 0 ;
12629 bool temp1 = false ;
12630 PyObject * obj0 = 0 ;
12631 char * kwnames[] = {
12632 (char *) "msg", NULL
12633 };
12634
12635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12636 {
12637 arg1 = wxString_in_helper(obj0);
12638 if (arg1 == NULL) SWIG_fail;
12639 temp1 = true;
12640 }
12641 {
12642 PyThreadState* __tstate = wxPyBeginAllowThreads();
12643 wxPyLogSysError((wxString const &)*arg1);
12644 wxPyEndAllowThreads(__tstate);
12645 if (PyErr_Occurred()) SWIG_fail;
12646 }
12647 resultobj = SWIG_Py_Void();
12648 {
12649 if (temp1)
12650 delete arg1;
12651 }
12652 return resultobj;
12653 fail:
12654 {
12655 if (temp1)
12656 delete arg1;
12657 }
12658 return NULL;
12659 }
12660
12661
12662 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj = 0;
12664 unsigned long arg1 ;
12665 wxString *arg2 = 0 ;
12666 unsigned long val1 ;
12667 int ecode1 = 0 ;
12668 bool temp2 = false ;
12669 PyObject * obj0 = 0 ;
12670 PyObject * obj1 = 0 ;
12671 char * kwnames[] = {
12672 (char *) "level",(char *) "msg", NULL
12673 };
12674
12675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12676 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12677 if (!SWIG_IsOK(ecode1)) {
12678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12679 }
12680 arg1 = static_cast< unsigned long >(val1);
12681 {
12682 arg2 = wxString_in_helper(obj1);
12683 if (arg2 == NULL) SWIG_fail;
12684 temp2 = true;
12685 }
12686 {
12687 PyThreadState* __tstate = wxPyBeginAllowThreads();
12688 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12689 wxPyEndAllowThreads(__tstate);
12690 if (PyErr_Occurred()) SWIG_fail;
12691 }
12692 resultobj = SWIG_Py_Void();
12693 {
12694 if (temp2)
12695 delete arg2;
12696 }
12697 return resultobj;
12698 fail:
12699 {
12700 if (temp2)
12701 delete arg2;
12702 }
12703 return NULL;
12704 }
12705
12706
12707 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12708 PyObject *resultobj = 0;
12709 unsigned long arg1 ;
12710 wxString *arg2 = 0 ;
12711 unsigned long val1 ;
12712 int ecode1 = 0 ;
12713 bool temp2 = false ;
12714
12715 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12716 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12717 if (!SWIG_IsOK(ecode1)) {
12718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12719 }
12720 arg1 = static_cast< unsigned long >(val1);
12721 {
12722 arg2 = wxString_in_helper(swig_obj[1]);
12723 if (arg2 == NULL) SWIG_fail;
12724 temp2 = true;
12725 }
12726 {
12727 PyThreadState* __tstate = wxPyBeginAllowThreads();
12728 wxPyLogTrace(arg1,(wxString const &)*arg2);
12729 wxPyEndAllowThreads(__tstate);
12730 if (PyErr_Occurred()) SWIG_fail;
12731 }
12732 resultobj = SWIG_Py_Void();
12733 {
12734 if (temp2)
12735 delete arg2;
12736 }
12737 return resultobj;
12738 fail:
12739 {
12740 if (temp2)
12741 delete arg2;
12742 }
12743 return NULL;
12744 }
12745
12746
12747 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12748 PyObject *resultobj = 0;
12749 wxString *arg1 = 0 ;
12750 wxString *arg2 = 0 ;
12751 bool temp1 = false ;
12752 bool temp2 = false ;
12753
12754 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12755 {
12756 arg1 = wxString_in_helper(swig_obj[0]);
12757 if (arg1 == NULL) SWIG_fail;
12758 temp1 = true;
12759 }
12760 {
12761 arg2 = wxString_in_helper(swig_obj[1]);
12762 if (arg2 == NULL) SWIG_fail;
12763 temp2 = true;
12764 }
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 resultobj = SWIG_Py_Void();
12772 {
12773 if (temp1)
12774 delete arg1;
12775 }
12776 {
12777 if (temp2)
12778 delete arg2;
12779 }
12780 return resultobj;
12781 fail:
12782 {
12783 if (temp1)
12784 delete arg1;
12785 }
12786 {
12787 if (temp2)
12788 delete arg2;
12789 }
12790 return NULL;
12791 }
12792
12793
12794 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12795 int argc;
12796 PyObject *argv[3];
12797
12798 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12799 --argc;
12800 if (argc == 2) {
12801 int _v = 0;
12802 {
12803 {
12804 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12805 }
12806 }
12807 if (!_v) goto check_1;
12808 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12809 }
12810 check_1:
12811
12812 if (argc == 2) {
12813 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12814 }
12815
12816 fail:
12817 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12818 return NULL;
12819 }
12820
12821
12822 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12823 PyObject *resultobj = 0;
12824 wxString *arg1 = 0 ;
12825 wxString *arg2 = 0 ;
12826 bool temp1 = false ;
12827 bool temp2 = false ;
12828 PyObject * obj0 = 0 ;
12829 PyObject * obj1 = 0 ;
12830 char * kwnames[] = {
12831 (char *) "title",(char *) "text", NULL
12832 };
12833
12834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12835 {
12836 arg1 = wxString_in_helper(obj0);
12837 if (arg1 == NULL) SWIG_fail;
12838 temp1 = true;
12839 }
12840 {
12841 arg2 = wxString_in_helper(obj1);
12842 if (arg2 == NULL) SWIG_fail;
12843 temp2 = true;
12844 }
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12848 wxPyEndAllowThreads(__tstate);
12849 if (PyErr_Occurred()) SWIG_fail;
12850 }
12851 resultobj = SWIG_Py_Void();
12852 {
12853 if (temp1)
12854 delete arg1;
12855 }
12856 {
12857 if (temp2)
12858 delete arg2;
12859 }
12860 return resultobj;
12861 fail:
12862 {
12863 if (temp1)
12864 delete arg1;
12865 }
12866 {
12867 if (temp2)
12868 delete arg2;
12869 }
12870 return NULL;
12871 }
12872
12873
12874 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12875 PyObject *resultobj = 0;
12876 wxLogNull *result = 0 ;
12877
12878 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12879 {
12880 PyThreadState* __tstate = wxPyBeginAllowThreads();
12881 result = (wxLogNull *)new wxLogNull();
12882 wxPyEndAllowThreads(__tstate);
12883 if (PyErr_Occurred()) SWIG_fail;
12884 }
12885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12886 return resultobj;
12887 fail:
12888 return NULL;
12889 }
12890
12891
12892 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12893 PyObject *resultobj = 0;
12894 wxLogNull *arg1 = (wxLogNull *) 0 ;
12895 void *argp1 = 0 ;
12896 int res1 = 0 ;
12897 PyObject *swig_obj[1] ;
12898
12899 if (!args) SWIG_fail;
12900 swig_obj[0] = args;
12901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12902 if (!SWIG_IsOK(res1)) {
12903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12904 }
12905 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 delete arg1;
12909
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 resultobj = SWIG_Py_Void();
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12921 PyObject *obj;
12922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12923 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12924 return SWIG_Py_Void();
12925 }
12926
12927 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 return SWIG_Python_InitShadowInstance(args);
12929 }
12930
12931 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12932 PyObject *resultobj = 0;
12933 wxPyLog *result = 0 ;
12934
12935 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12936 {
12937 PyThreadState* __tstate = wxPyBeginAllowThreads();
12938 result = (wxPyLog *)new wxPyLog();
12939 wxPyEndAllowThreads(__tstate);
12940 if (PyErr_Occurred()) SWIG_fail;
12941 }
12942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12943 return resultobj;
12944 fail:
12945 return NULL;
12946 }
12947
12948
12949 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj = 0;
12951 wxPyLog *arg1 = (wxPyLog *) 0 ;
12952 PyObject *arg2 = (PyObject *) 0 ;
12953 PyObject *arg3 = (PyObject *) 0 ;
12954 void *argp1 = 0 ;
12955 int res1 = 0 ;
12956 PyObject * obj0 = 0 ;
12957 PyObject * obj1 = 0 ;
12958 PyObject * obj2 = 0 ;
12959 char * kwnames[] = {
12960 (char *) "self",(char *) "self",(char *) "_class", NULL
12961 };
12962
12963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12965 if (!SWIG_IsOK(res1)) {
12966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12967 }
12968 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12969 arg2 = obj1;
12970 arg3 = obj2;
12971 {
12972 PyThreadState* __tstate = wxPyBeginAllowThreads();
12973 (arg1)->_setCallbackInfo(arg2,arg3);
12974 wxPyEndAllowThreads(__tstate);
12975 if (PyErr_Occurred()) SWIG_fail;
12976 }
12977 resultobj = SWIG_Py_Void();
12978 return resultobj;
12979 fail:
12980 return NULL;
12981 }
12982
12983
12984 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12985 PyObject *obj;
12986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12987 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12988 return SWIG_Py_Void();
12989 }
12990
12991 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12992 return SWIG_Python_InitShadowInstance(args);
12993 }
12994
12995 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12996 PyObject *resultobj = 0;
12997 int arg1 ;
12998 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12999 int arg3 = (int) wxKILL_NOCHILDREN ;
13000 wxKillError result;
13001 int val1 ;
13002 int ecode1 = 0 ;
13003 int val2 ;
13004 int ecode2 = 0 ;
13005 int val3 ;
13006 int ecode3 = 0 ;
13007 PyObject * obj0 = 0 ;
13008 PyObject * obj1 = 0 ;
13009 PyObject * obj2 = 0 ;
13010 char * kwnames[] = {
13011 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13012 };
13013
13014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13015 ecode1 = SWIG_AsVal_int(obj0, &val1);
13016 if (!SWIG_IsOK(ecode1)) {
13017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13018 }
13019 arg1 = static_cast< int >(val1);
13020 if (obj1) {
13021 ecode2 = SWIG_AsVal_int(obj1, &val2);
13022 if (!SWIG_IsOK(ecode2)) {
13023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13024 }
13025 arg2 = static_cast< wxSignal >(val2);
13026 }
13027 if (obj2) {
13028 ecode3 = SWIG_AsVal_int(obj2, &val3);
13029 if (!SWIG_IsOK(ecode3)) {
13030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13031 }
13032 arg3 = static_cast< int >(val3);
13033 }
13034 {
13035 PyThreadState* __tstate = wxPyBeginAllowThreads();
13036 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13037 wxPyEndAllowThreads(__tstate);
13038 if (PyErr_Occurred()) SWIG_fail;
13039 }
13040 resultobj = SWIG_From_int(static_cast< int >(result));
13041 return resultobj;
13042 fail:
13043 return NULL;
13044 }
13045
13046
13047 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13048 PyObject *resultobj = 0;
13049 int arg1 ;
13050 bool result;
13051 int val1 ;
13052 int ecode1 = 0 ;
13053 PyObject * obj0 = 0 ;
13054 char * kwnames[] = {
13055 (char *) "pid", NULL
13056 };
13057
13058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13059 ecode1 = SWIG_AsVal_int(obj0, &val1);
13060 if (!SWIG_IsOK(ecode1)) {
13061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13062 }
13063 arg1 = static_cast< int >(val1);
13064 {
13065 PyThreadState* __tstate = wxPyBeginAllowThreads();
13066 result = (bool)wxPyProcess::Exists(arg1);
13067 wxPyEndAllowThreads(__tstate);
13068 if (PyErr_Occurred()) SWIG_fail;
13069 }
13070 {
13071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13072 }
13073 return resultobj;
13074 fail:
13075 return NULL;
13076 }
13077
13078
13079 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13080 PyObject *resultobj = 0;
13081 wxString *arg1 = 0 ;
13082 int arg2 = (int) wxEXEC_ASYNC ;
13083 wxPyProcess *result = 0 ;
13084 bool temp1 = false ;
13085 int val2 ;
13086 int ecode2 = 0 ;
13087 PyObject * obj0 = 0 ;
13088 PyObject * obj1 = 0 ;
13089 char * kwnames[] = {
13090 (char *) "cmd",(char *) "flags", NULL
13091 };
13092
13093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13094 {
13095 arg1 = wxString_in_helper(obj0);
13096 if (arg1 == NULL) SWIG_fail;
13097 temp1 = true;
13098 }
13099 if (obj1) {
13100 ecode2 = SWIG_AsVal_int(obj1, &val2);
13101 if (!SWIG_IsOK(ecode2)) {
13102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13103 }
13104 arg2 = static_cast< int >(val2);
13105 }
13106 {
13107 PyThreadState* __tstate = wxPyBeginAllowThreads();
13108 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13109 wxPyEndAllowThreads(__tstate);
13110 if (PyErr_Occurred()) SWIG_fail;
13111 }
13112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13113 {
13114 if (temp1)
13115 delete arg1;
13116 }
13117 return resultobj;
13118 fail:
13119 {
13120 if (temp1)
13121 delete arg1;
13122 }
13123 return NULL;
13124 }
13125
13126
13127 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj = 0;
13129 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13130 int arg2 = (int) -1 ;
13131 wxPyProcess *result = 0 ;
13132 void *argp1 = 0 ;
13133 int res1 = 0 ;
13134 int val2 ;
13135 int ecode2 = 0 ;
13136 PyObject * obj0 = 0 ;
13137 PyObject * obj1 = 0 ;
13138 char * kwnames[] = {
13139 (char *) "parent",(char *) "id", NULL
13140 };
13141
13142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13143 if (obj0) {
13144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13145 if (!SWIG_IsOK(res1)) {
13146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13147 }
13148 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13149 }
13150 if (obj1) {
13151 ecode2 = SWIG_AsVal_int(obj1, &val2);
13152 if (!SWIG_IsOK(ecode2)) {
13153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13154 }
13155 arg2 = static_cast< int >(val2);
13156 }
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13164 return resultobj;
13165 fail:
13166 return NULL;
13167 }
13168
13169
13170 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13171 PyObject *resultobj = 0;
13172 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13173 PyObject *arg2 = (PyObject *) 0 ;
13174 PyObject *arg3 = (PyObject *) 0 ;
13175 void *argp1 = 0 ;
13176 int res1 = 0 ;
13177 PyObject * obj0 = 0 ;
13178 PyObject * obj1 = 0 ;
13179 PyObject * obj2 = 0 ;
13180 char * kwnames[] = {
13181 (char *) "self",(char *) "self",(char *) "_class", NULL
13182 };
13183
13184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13186 if (!SWIG_IsOK(res1)) {
13187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13188 }
13189 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13190 arg2 = obj1;
13191 arg3 = obj2;
13192 {
13193 PyThreadState* __tstate = wxPyBeginAllowThreads();
13194 (arg1)->_setCallbackInfo(arg2,arg3);
13195 wxPyEndAllowThreads(__tstate);
13196 if (PyErr_Occurred()) SWIG_fail;
13197 }
13198 resultobj = SWIG_Py_Void();
13199 return resultobj;
13200 fail:
13201 return NULL;
13202 }
13203
13204
13205 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13206 PyObject *resultobj = 0;
13207 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13208 int arg2 ;
13209 int arg3 ;
13210 void *argp1 = 0 ;
13211 int res1 = 0 ;
13212 int val2 ;
13213 int ecode2 = 0 ;
13214 int val3 ;
13215 int ecode3 = 0 ;
13216 PyObject * obj0 = 0 ;
13217 PyObject * obj1 = 0 ;
13218 PyObject * obj2 = 0 ;
13219 char * kwnames[] = {
13220 (char *) "self",(char *) "pid",(char *) "status", NULL
13221 };
13222
13223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13225 if (!SWIG_IsOK(res1)) {
13226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13227 }
13228 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13229 ecode2 = SWIG_AsVal_int(obj1, &val2);
13230 if (!SWIG_IsOK(ecode2)) {
13231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13232 }
13233 arg2 = static_cast< int >(val2);
13234 ecode3 = SWIG_AsVal_int(obj2, &val3);
13235 if (!SWIG_IsOK(ecode3)) {
13236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13237 }
13238 arg3 = static_cast< int >(val3);
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 (arg1)->OnTerminate(arg2,arg3);
13242 wxPyEndAllowThreads(__tstate);
13243 if (PyErr_Occurred()) SWIG_fail;
13244 }
13245 resultobj = SWIG_Py_Void();
13246 return resultobj;
13247 fail:
13248 return NULL;
13249 }
13250
13251
13252 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13253 PyObject *resultobj = 0;
13254 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13255 void *argp1 = 0 ;
13256 int res1 = 0 ;
13257 PyObject *swig_obj[1] ;
13258
13259 if (!args) SWIG_fail;
13260 swig_obj[0] = args;
13261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13262 if (!SWIG_IsOK(res1)) {
13263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13264 }
13265 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13266 {
13267 PyThreadState* __tstate = wxPyBeginAllowThreads();
13268 (arg1)->Redirect();
13269 wxPyEndAllowThreads(__tstate);
13270 if (PyErr_Occurred()) SWIG_fail;
13271 }
13272 resultobj = SWIG_Py_Void();
13273 return resultobj;
13274 fail:
13275 return NULL;
13276 }
13277
13278
13279 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13280 PyObject *resultobj = 0;
13281 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13282 bool result;
13283 void *argp1 = 0 ;
13284 int res1 = 0 ;
13285 PyObject *swig_obj[1] ;
13286
13287 if (!args) SWIG_fail;
13288 swig_obj[0] = args;
13289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13290 if (!SWIG_IsOK(res1)) {
13291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13292 }
13293 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13294 {
13295 PyThreadState* __tstate = wxPyBeginAllowThreads();
13296 result = (bool)(arg1)->IsRedirected();
13297 wxPyEndAllowThreads(__tstate);
13298 if (PyErr_Occurred()) SWIG_fail;
13299 }
13300 {
13301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13302 }
13303 return resultobj;
13304 fail:
13305 return NULL;
13306 }
13307
13308
13309 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13310 PyObject *resultobj = 0;
13311 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13312 void *argp1 = 0 ;
13313 int res1 = 0 ;
13314 PyObject *swig_obj[1] ;
13315
13316 if (!args) SWIG_fail;
13317 swig_obj[0] = args;
13318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13319 if (!SWIG_IsOK(res1)) {
13320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13321 }
13322 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13323 {
13324 PyThreadState* __tstate = wxPyBeginAllowThreads();
13325 (arg1)->Detach();
13326 wxPyEndAllowThreads(__tstate);
13327 if (PyErr_Occurred()) SWIG_fail;
13328 }
13329 resultobj = SWIG_Py_Void();
13330 return resultobj;
13331 fail:
13332 return NULL;
13333 }
13334
13335
13336 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13337 PyObject *resultobj = 0;
13338 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13339 wxInputStream *result = 0 ;
13340 void *argp1 = 0 ;
13341 int res1 = 0 ;
13342 PyObject *swig_obj[1] ;
13343
13344 if (!args) SWIG_fail;
13345 swig_obj[0] = args;
13346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13347 if (!SWIG_IsOK(res1)) {
13348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13349 }
13350 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13351 {
13352 PyThreadState* __tstate = wxPyBeginAllowThreads();
13353 result = (wxInputStream *)(arg1)->GetInputStream();
13354 wxPyEndAllowThreads(__tstate);
13355 if (PyErr_Occurred()) SWIG_fail;
13356 }
13357 {
13358 wxPyInputStream * _ptr = NULL;
13359
13360 if (result) {
13361 _ptr = new wxPyInputStream(result);
13362 }
13363 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13364 }
13365 return resultobj;
13366 fail:
13367 return NULL;
13368 }
13369
13370
13371 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13372 PyObject *resultobj = 0;
13373 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13374 wxInputStream *result = 0 ;
13375 void *argp1 = 0 ;
13376 int res1 = 0 ;
13377 PyObject *swig_obj[1] ;
13378
13379 if (!args) SWIG_fail;
13380 swig_obj[0] = args;
13381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13382 if (!SWIG_IsOK(res1)) {
13383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13384 }
13385 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13386 {
13387 PyThreadState* __tstate = wxPyBeginAllowThreads();
13388 result = (wxInputStream *)(arg1)->GetErrorStream();
13389 wxPyEndAllowThreads(__tstate);
13390 if (PyErr_Occurred()) SWIG_fail;
13391 }
13392 {
13393 wxPyInputStream * _ptr = NULL;
13394
13395 if (result) {
13396 _ptr = new wxPyInputStream(result);
13397 }
13398 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13399 }
13400 return resultobj;
13401 fail:
13402 return NULL;
13403 }
13404
13405
13406 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13407 PyObject *resultobj = 0;
13408 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13409 wxOutputStream *result = 0 ;
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_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13419 }
13420 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13421 {
13422 PyThreadState* __tstate = wxPyBeginAllowThreads();
13423 result = (wxOutputStream *)(arg1)->GetOutputStream();
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13428 return resultobj;
13429 fail:
13430 return NULL;
13431 }
13432
13433
13434 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13435 PyObject *resultobj = 0;
13436 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13437 void *argp1 = 0 ;
13438 int res1 = 0 ;
13439 PyObject *swig_obj[1] ;
13440
13441 if (!args) SWIG_fail;
13442 swig_obj[0] = args;
13443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13444 if (!SWIG_IsOK(res1)) {
13445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13446 }
13447 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13448 {
13449 PyThreadState* __tstate = wxPyBeginAllowThreads();
13450 (arg1)->CloseOutput();
13451 wxPyEndAllowThreads(__tstate);
13452 if (PyErr_Occurred()) SWIG_fail;
13453 }
13454 resultobj = SWIG_Py_Void();
13455 return resultobj;
13456 fail:
13457 return NULL;
13458 }
13459
13460
13461 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13462 PyObject *resultobj = 0;
13463 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13464 bool result;
13465 void *argp1 = 0 ;
13466 int res1 = 0 ;
13467 PyObject *swig_obj[1] ;
13468
13469 if (!args) SWIG_fail;
13470 swig_obj[0] = args;
13471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13472 if (!SWIG_IsOK(res1)) {
13473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13474 }
13475 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13476 {
13477 PyThreadState* __tstate = wxPyBeginAllowThreads();
13478 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13479 wxPyEndAllowThreads(__tstate);
13480 if (PyErr_Occurred()) SWIG_fail;
13481 }
13482 {
13483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13484 }
13485 return resultobj;
13486 fail:
13487 return NULL;
13488 }
13489
13490
13491 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13492 PyObject *resultobj = 0;
13493 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13494 bool result;
13495 void *argp1 = 0 ;
13496 int res1 = 0 ;
13497 PyObject *swig_obj[1] ;
13498
13499 if (!args) SWIG_fail;
13500 swig_obj[0] = args;
13501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13502 if (!SWIG_IsOK(res1)) {
13503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13504 }
13505 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13506 {
13507 PyThreadState* __tstate = wxPyBeginAllowThreads();
13508 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13509 wxPyEndAllowThreads(__tstate);
13510 if (PyErr_Occurred()) SWIG_fail;
13511 }
13512 {
13513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13514 }
13515 return resultobj;
13516 fail:
13517 return NULL;
13518 }
13519
13520
13521 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13522 PyObject *resultobj = 0;
13523 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13524 bool result;
13525 void *argp1 = 0 ;
13526 int res1 = 0 ;
13527 PyObject *swig_obj[1] ;
13528
13529 if (!args) SWIG_fail;
13530 swig_obj[0] = args;
13531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13532 if (!SWIG_IsOK(res1)) {
13533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13534 }
13535 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13536 {
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13539 wxPyEndAllowThreads(__tstate);
13540 if (PyErr_Occurred()) SWIG_fail;
13541 }
13542 {
13543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13544 }
13545 return resultobj;
13546 fail:
13547 return NULL;
13548 }
13549
13550
13551 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13552 PyObject *obj;
13553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13554 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13555 return SWIG_Py_Void();
13556 }
13557
13558 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13559 return SWIG_Python_InitShadowInstance(args);
13560 }
13561
13562 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13563 PyObject *resultobj = 0;
13564 int arg1 = (int) 0 ;
13565 int arg2 = (int) 0 ;
13566 int arg3 = (int) 0 ;
13567 wxProcessEvent *result = 0 ;
13568 int val1 ;
13569 int ecode1 = 0 ;
13570 int val2 ;
13571 int ecode2 = 0 ;
13572 int val3 ;
13573 int ecode3 = 0 ;
13574 PyObject * obj0 = 0 ;
13575 PyObject * obj1 = 0 ;
13576 PyObject * obj2 = 0 ;
13577 char * kwnames[] = {
13578 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13579 };
13580
13581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13582 if (obj0) {
13583 ecode1 = SWIG_AsVal_int(obj0, &val1);
13584 if (!SWIG_IsOK(ecode1)) {
13585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13586 }
13587 arg1 = static_cast< int >(val1);
13588 }
13589 if (obj1) {
13590 ecode2 = SWIG_AsVal_int(obj1, &val2);
13591 if (!SWIG_IsOK(ecode2)) {
13592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13593 }
13594 arg2 = static_cast< int >(val2);
13595 }
13596 if (obj2) {
13597 ecode3 = SWIG_AsVal_int(obj2, &val3);
13598 if (!SWIG_IsOK(ecode3)) {
13599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13600 }
13601 arg3 = static_cast< int >(val3);
13602 }
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13610 return resultobj;
13611 fail:
13612 return NULL;
13613 }
13614
13615
13616 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13617 PyObject *resultobj = 0;
13618 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13619 int result;
13620 void *argp1 = 0 ;
13621 int res1 = 0 ;
13622 PyObject *swig_obj[1] ;
13623
13624 if (!args) SWIG_fail;
13625 swig_obj[0] = args;
13626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13627 if (!SWIG_IsOK(res1)) {
13628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13629 }
13630 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 result = (int)(arg1)->GetPid();
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 resultobj = SWIG_From_int(static_cast< int >(result));
13638 return resultobj;
13639 fail:
13640 return NULL;
13641 }
13642
13643
13644 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13645 PyObject *resultobj = 0;
13646 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13647 int result;
13648 void *argp1 = 0 ;
13649 int res1 = 0 ;
13650 PyObject *swig_obj[1] ;
13651
13652 if (!args) SWIG_fail;
13653 swig_obj[0] = args;
13654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13655 if (!SWIG_IsOK(res1)) {
13656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13657 }
13658 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13659 {
13660 PyThreadState* __tstate = wxPyBeginAllowThreads();
13661 result = (int)(arg1)->GetExitCode();
13662 wxPyEndAllowThreads(__tstate);
13663 if (PyErr_Occurred()) SWIG_fail;
13664 }
13665 resultobj = SWIG_From_int(static_cast< int >(result));
13666 return resultobj;
13667 fail:
13668 return NULL;
13669 }
13670
13671
13672 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13673 PyObject *resultobj = 0;
13674 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13675 int arg2 ;
13676 void *argp1 = 0 ;
13677 int res1 = 0 ;
13678 int val2 ;
13679 int ecode2 = 0 ;
13680 PyObject *swig_obj[2] ;
13681
13682 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13684 if (!SWIG_IsOK(res1)) {
13685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13686 }
13687 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13688 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13689 if (!SWIG_IsOK(ecode2)) {
13690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13691 }
13692 arg2 = static_cast< int >(val2);
13693 if (arg1) (arg1)->m_pid = arg2;
13694
13695 resultobj = SWIG_Py_Void();
13696 return resultobj;
13697 fail:
13698 return NULL;
13699 }
13700
13701
13702 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13703 PyObject *resultobj = 0;
13704 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13705 int result;
13706 void *argp1 = 0 ;
13707 int res1 = 0 ;
13708 PyObject *swig_obj[1] ;
13709
13710 if (!args) SWIG_fail;
13711 swig_obj[0] = args;
13712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13713 if (!SWIG_IsOK(res1)) {
13714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13715 }
13716 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13717 result = (int) ((arg1)->m_pid);
13718 resultobj = SWIG_From_int(static_cast< int >(result));
13719 return resultobj;
13720 fail:
13721 return NULL;
13722 }
13723
13724
13725 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13726 PyObject *resultobj = 0;
13727 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13728 int arg2 ;
13729 void *argp1 = 0 ;
13730 int res1 = 0 ;
13731 int val2 ;
13732 int ecode2 = 0 ;
13733 PyObject *swig_obj[2] ;
13734
13735 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13737 if (!SWIG_IsOK(res1)) {
13738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13739 }
13740 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13741 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13742 if (!SWIG_IsOK(ecode2)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13744 }
13745 arg2 = static_cast< int >(val2);
13746 if (arg1) (arg1)->m_exitcode = arg2;
13747
13748 resultobj = SWIG_Py_Void();
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13756 PyObject *resultobj = 0;
13757 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13758 int result;
13759 void *argp1 = 0 ;
13760 int res1 = 0 ;
13761 PyObject *swig_obj[1] ;
13762
13763 if (!args) SWIG_fail;
13764 swig_obj[0] = args;
13765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13766 if (!SWIG_IsOK(res1)) {
13767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13768 }
13769 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13770 result = (int) ((arg1)->m_exitcode);
13771 resultobj = SWIG_From_int(static_cast< int >(result));
13772 return resultobj;
13773 fail:
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13779 PyObject *obj;
13780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13781 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13782 return SWIG_Py_Void();
13783 }
13784
13785 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13786 return SWIG_Python_InitShadowInstance(args);
13787 }
13788
13789 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13790 PyObject *resultobj = 0;
13791 wxString *arg1 = 0 ;
13792 int arg2 = (int) wxEXEC_ASYNC ;
13793 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13794 long result;
13795 bool temp1 = false ;
13796 int val2 ;
13797 int ecode2 = 0 ;
13798 void *argp3 = 0 ;
13799 int res3 = 0 ;
13800 PyObject * obj0 = 0 ;
13801 PyObject * obj1 = 0 ;
13802 PyObject * obj2 = 0 ;
13803 char * kwnames[] = {
13804 (char *) "command",(char *) "flags",(char *) "process", NULL
13805 };
13806
13807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13808 {
13809 arg1 = wxString_in_helper(obj0);
13810 if (arg1 == NULL) SWIG_fail;
13811 temp1 = true;
13812 }
13813 if (obj1) {
13814 ecode2 = SWIG_AsVal_int(obj1, &val2);
13815 if (!SWIG_IsOK(ecode2)) {
13816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13817 }
13818 arg2 = static_cast< int >(val2);
13819 }
13820 if (obj2) {
13821 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13822 if (!SWIG_IsOK(res3)) {
13823 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13824 }
13825 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13826 }
13827 {
13828 if (!wxPyCheckForApp()) SWIG_fail;
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 resultobj = SWIG_From_long(static_cast< long >(result));
13835 {
13836 if (temp1)
13837 delete arg1;
13838 }
13839 return resultobj;
13840 fail:
13841 {
13842 if (temp1)
13843 delete arg1;
13844 }
13845 return NULL;
13846 }
13847
13848
13849 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13850 PyObject *resultobj = 0;
13851 long arg1 ;
13852 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13853 wxKillError *arg3 = (wxKillError *) 0 ;
13854 int arg4 = (int) wxKILL_NOCHILDREN ;
13855 int result;
13856 long val1 ;
13857 int ecode1 = 0 ;
13858 int val2 ;
13859 int ecode2 = 0 ;
13860 wxKillError temp3 ;
13861 int val4 ;
13862 int ecode4 = 0 ;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 PyObject * obj2 = 0 ;
13866 char * kwnames[] = {
13867 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13868 };
13869
13870 {
13871 arg3 = &temp3;
13872 }
13873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13874 ecode1 = SWIG_AsVal_long(obj0, &val1);
13875 if (!SWIG_IsOK(ecode1)) {
13876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13877 }
13878 arg1 = static_cast< long >(val1);
13879 if (obj1) {
13880 ecode2 = SWIG_AsVal_int(obj1, &val2);
13881 if (!SWIG_IsOK(ecode2)) {
13882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13883 }
13884 arg2 = static_cast< wxSignal >(val2);
13885 }
13886 if (obj2) {
13887 ecode4 = SWIG_AsVal_int(obj2, &val4);
13888 if (!SWIG_IsOK(ecode4)) {
13889 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13890 }
13891 arg4 = static_cast< int >(val4);
13892 }
13893 {
13894 PyThreadState* __tstate = wxPyBeginAllowThreads();
13895 result = (int)wxKill(arg1,arg2,arg3,arg4);
13896 wxPyEndAllowThreads(__tstate);
13897 if (PyErr_Occurred()) SWIG_fail;
13898 }
13899 resultobj = SWIG_From_int(static_cast< int >(result));
13900 {
13901 PyObject* o;
13902 o = PyInt_FromLong((long) (*arg3));
13903
13904
13905
13906 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13907
13908 }
13909 return resultobj;
13910 fail:
13911 return NULL;
13912 }
13913
13914
13915 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13916 PyObject *resultobj = 0;
13917 int arg1 = (int) wxJOYSTICK1 ;
13918 wxJoystick *result = 0 ;
13919 int val1 ;
13920 int ecode1 = 0 ;
13921 PyObject * obj0 = 0 ;
13922 char * kwnames[] = {
13923 (char *) "joystick", NULL
13924 };
13925
13926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13927 if (obj0) {
13928 ecode1 = SWIG_AsVal_int(obj0, &val1);
13929 if (!SWIG_IsOK(ecode1)) {
13930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13931 }
13932 arg1 = static_cast< int >(val1);
13933 }
13934 {
13935 if (!wxPyCheckForApp()) SWIG_fail;
13936 PyThreadState* __tstate = wxPyBeginAllowThreads();
13937 result = (wxJoystick *)new wxJoystick(arg1);
13938 wxPyEndAllowThreads(__tstate);
13939 if (PyErr_Occurred()) SWIG_fail;
13940 }
13941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13942 return resultobj;
13943 fail:
13944 return NULL;
13945 }
13946
13947
13948 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13949 PyObject *resultobj = 0;
13950 wxJoystick *arg1 = (wxJoystick *) 0 ;
13951 void *argp1 = 0 ;
13952 int res1 = 0 ;
13953 PyObject *swig_obj[1] ;
13954
13955 if (!args) SWIG_fail;
13956 swig_obj[0] = args;
13957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13958 if (!SWIG_IsOK(res1)) {
13959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13960 }
13961 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13962 {
13963 PyThreadState* __tstate = wxPyBeginAllowThreads();
13964 delete arg1;
13965
13966 wxPyEndAllowThreads(__tstate);
13967 if (PyErr_Occurred()) SWIG_fail;
13968 }
13969 resultobj = SWIG_Py_Void();
13970 return resultobj;
13971 fail:
13972 return NULL;
13973 }
13974
13975
13976 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13977 PyObject *resultobj = 0;
13978 wxJoystick *arg1 = (wxJoystick *) 0 ;
13979 wxPoint result;
13980 void *argp1 = 0 ;
13981 int res1 = 0 ;
13982 PyObject *swig_obj[1] ;
13983
13984 if (!args) SWIG_fail;
13985 swig_obj[0] = args;
13986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13987 if (!SWIG_IsOK(res1)) {
13988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13989 }
13990 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13991 {
13992 PyThreadState* __tstate = wxPyBeginAllowThreads();
13993 result = (arg1)->GetPosition();
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13998 return resultobj;
13999 fail:
14000 return NULL;
14001 }
14002
14003
14004 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14005 PyObject *resultobj = 0;
14006 wxJoystick *arg1 = (wxJoystick *) 0 ;
14007 int result;
14008 void *argp1 = 0 ;
14009 int res1 = 0 ;
14010 PyObject *swig_obj[1] ;
14011
14012 if (!args) SWIG_fail;
14013 swig_obj[0] = args;
14014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14015 if (!SWIG_IsOK(res1)) {
14016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14017 }
14018 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14019 {
14020 PyThreadState* __tstate = wxPyBeginAllowThreads();
14021 result = (int)(arg1)->GetZPosition();
14022 wxPyEndAllowThreads(__tstate);
14023 if (PyErr_Occurred()) SWIG_fail;
14024 }
14025 resultobj = SWIG_From_int(static_cast< int >(result));
14026 return resultobj;
14027 fail:
14028 return NULL;
14029 }
14030
14031
14032 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14033 PyObject *resultobj = 0;
14034 wxJoystick *arg1 = (wxJoystick *) 0 ;
14035 int result;
14036 void *argp1 = 0 ;
14037 int res1 = 0 ;
14038 PyObject *swig_obj[1] ;
14039
14040 if (!args) SWIG_fail;
14041 swig_obj[0] = args;
14042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14043 if (!SWIG_IsOK(res1)) {
14044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14045 }
14046 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14047 {
14048 PyThreadState* __tstate = wxPyBeginAllowThreads();
14049 result = (int)(arg1)->GetButtonState();
14050 wxPyEndAllowThreads(__tstate);
14051 if (PyErr_Occurred()) SWIG_fail;
14052 }
14053 resultobj = SWIG_From_int(static_cast< int >(result));
14054 return resultobj;
14055 fail:
14056 return NULL;
14057 }
14058
14059
14060 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14061 PyObject *resultobj = 0;
14062 wxJoystick *arg1 = (wxJoystick *) 0 ;
14063 int result;
14064 void *argp1 = 0 ;
14065 int res1 = 0 ;
14066 PyObject *swig_obj[1] ;
14067
14068 if (!args) SWIG_fail;
14069 swig_obj[0] = args;
14070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14071 if (!SWIG_IsOK(res1)) {
14072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14073 }
14074 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14075 {
14076 PyThreadState* __tstate = wxPyBeginAllowThreads();
14077 result = (int)(arg1)->GetPOVPosition();
14078 wxPyEndAllowThreads(__tstate);
14079 if (PyErr_Occurred()) SWIG_fail;
14080 }
14081 resultobj = SWIG_From_int(static_cast< int >(result));
14082 return resultobj;
14083 fail:
14084 return NULL;
14085 }
14086
14087
14088 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14089 PyObject *resultobj = 0;
14090 wxJoystick *arg1 = (wxJoystick *) 0 ;
14091 int result;
14092 void *argp1 = 0 ;
14093 int res1 = 0 ;
14094 PyObject *swig_obj[1] ;
14095
14096 if (!args) SWIG_fail;
14097 swig_obj[0] = args;
14098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14099 if (!SWIG_IsOK(res1)) {
14100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14101 }
14102 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14103 {
14104 PyThreadState* __tstate = wxPyBeginAllowThreads();
14105 result = (int)(arg1)->GetPOVCTSPosition();
14106 wxPyEndAllowThreads(__tstate);
14107 if (PyErr_Occurred()) SWIG_fail;
14108 }
14109 resultobj = SWIG_From_int(static_cast< int >(result));
14110 return resultobj;
14111 fail:
14112 return NULL;
14113 }
14114
14115
14116 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14117 PyObject *resultobj = 0;
14118 wxJoystick *arg1 = (wxJoystick *) 0 ;
14119 int result;
14120 void *argp1 = 0 ;
14121 int res1 = 0 ;
14122 PyObject *swig_obj[1] ;
14123
14124 if (!args) SWIG_fail;
14125 swig_obj[0] = args;
14126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14127 if (!SWIG_IsOK(res1)) {
14128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14129 }
14130 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14131 {
14132 PyThreadState* __tstate = wxPyBeginAllowThreads();
14133 result = (int)(arg1)->GetRudderPosition();
14134 wxPyEndAllowThreads(__tstate);
14135 if (PyErr_Occurred()) SWIG_fail;
14136 }
14137 resultobj = SWIG_From_int(static_cast< int >(result));
14138 return resultobj;
14139 fail:
14140 return NULL;
14141 }
14142
14143
14144 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14145 PyObject *resultobj = 0;
14146 wxJoystick *arg1 = (wxJoystick *) 0 ;
14147 int result;
14148 void *argp1 = 0 ;
14149 int res1 = 0 ;
14150 PyObject *swig_obj[1] ;
14151
14152 if (!args) SWIG_fail;
14153 swig_obj[0] = args;
14154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14155 if (!SWIG_IsOK(res1)) {
14156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14157 }
14158 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 result = (int)(arg1)->GetUPosition();
14162 wxPyEndAllowThreads(__tstate);
14163 if (PyErr_Occurred()) SWIG_fail;
14164 }
14165 resultobj = SWIG_From_int(static_cast< int >(result));
14166 return resultobj;
14167 fail:
14168 return NULL;
14169 }
14170
14171
14172 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14173 PyObject *resultobj = 0;
14174 wxJoystick *arg1 = (wxJoystick *) 0 ;
14175 int result;
14176 void *argp1 = 0 ;
14177 int res1 = 0 ;
14178 PyObject *swig_obj[1] ;
14179
14180 if (!args) SWIG_fail;
14181 swig_obj[0] = args;
14182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14183 if (!SWIG_IsOK(res1)) {
14184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14185 }
14186 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 result = (int)(arg1)->GetVPosition();
14190 wxPyEndAllowThreads(__tstate);
14191 if (PyErr_Occurred()) SWIG_fail;
14192 }
14193 resultobj = SWIG_From_int(static_cast< int >(result));
14194 return resultobj;
14195 fail:
14196 return NULL;
14197 }
14198
14199
14200 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14201 PyObject *resultobj = 0;
14202 wxJoystick *arg1 = (wxJoystick *) 0 ;
14203 int result;
14204 void *argp1 = 0 ;
14205 int res1 = 0 ;
14206 PyObject *swig_obj[1] ;
14207
14208 if (!args) SWIG_fail;
14209 swig_obj[0] = args;
14210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14211 if (!SWIG_IsOK(res1)) {
14212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14213 }
14214 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14215 {
14216 PyThreadState* __tstate = wxPyBeginAllowThreads();
14217 result = (int)(arg1)->GetMovementThreshold();
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 resultobj = SWIG_From_int(static_cast< int >(result));
14222 return resultobj;
14223 fail:
14224 return NULL;
14225 }
14226
14227
14228 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14229 PyObject *resultobj = 0;
14230 wxJoystick *arg1 = (wxJoystick *) 0 ;
14231 int arg2 ;
14232 void *argp1 = 0 ;
14233 int res1 = 0 ;
14234 int val2 ;
14235 int ecode2 = 0 ;
14236 PyObject * obj0 = 0 ;
14237 PyObject * obj1 = 0 ;
14238 char * kwnames[] = {
14239 (char *) "self",(char *) "threshold", NULL
14240 };
14241
14242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14244 if (!SWIG_IsOK(res1)) {
14245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14246 }
14247 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14248 ecode2 = SWIG_AsVal_int(obj1, &val2);
14249 if (!SWIG_IsOK(ecode2)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14251 }
14252 arg2 = static_cast< int >(val2);
14253 {
14254 PyThreadState* __tstate = wxPyBeginAllowThreads();
14255 (arg1)->SetMovementThreshold(arg2);
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 resultobj = SWIG_Py_Void();
14260 return resultobj;
14261 fail:
14262 return NULL;
14263 }
14264
14265
14266 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14267 PyObject *resultobj = 0;
14268 wxJoystick *arg1 = (wxJoystick *) 0 ;
14269 bool result;
14270 void *argp1 = 0 ;
14271 int res1 = 0 ;
14272 PyObject *swig_obj[1] ;
14273
14274 if (!args) SWIG_fail;
14275 swig_obj[0] = args;
14276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14277 if (!SWIG_IsOK(res1)) {
14278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14279 }
14280 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 result = (bool)(arg1)->IsOk();
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 {
14288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14289 }
14290 return resultobj;
14291 fail:
14292 return NULL;
14293 }
14294
14295
14296 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14297 PyObject *resultobj = 0;
14298 wxJoystick *arg1 = (wxJoystick *) 0 ;
14299 int result;
14300 void *argp1 = 0 ;
14301 int res1 = 0 ;
14302 PyObject *swig_obj[1] ;
14303
14304 if (!args) SWIG_fail;
14305 swig_obj[0] = args;
14306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14307 if (!SWIG_IsOK(res1)) {
14308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14309 }
14310 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 result = (int)(arg1)->GetNumberJoysticks();
14314 wxPyEndAllowThreads(__tstate);
14315 if (PyErr_Occurred()) SWIG_fail;
14316 }
14317 resultobj = SWIG_From_int(static_cast< int >(result));
14318 return resultobj;
14319 fail:
14320 return NULL;
14321 }
14322
14323
14324 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14325 PyObject *resultobj = 0;
14326 wxJoystick *arg1 = (wxJoystick *) 0 ;
14327 int result;
14328 void *argp1 = 0 ;
14329 int res1 = 0 ;
14330 PyObject *swig_obj[1] ;
14331
14332 if (!args) SWIG_fail;
14333 swig_obj[0] = args;
14334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14335 if (!SWIG_IsOK(res1)) {
14336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14337 }
14338 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14339 {
14340 PyThreadState* __tstate = wxPyBeginAllowThreads();
14341 result = (int)(arg1)->GetManufacturerId();
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 resultobj = SWIG_From_int(static_cast< int >(result));
14346 return resultobj;
14347 fail:
14348 return NULL;
14349 }
14350
14351
14352 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14353 PyObject *resultobj = 0;
14354 wxJoystick *arg1 = (wxJoystick *) 0 ;
14355 int result;
14356 void *argp1 = 0 ;
14357 int res1 = 0 ;
14358 PyObject *swig_obj[1] ;
14359
14360 if (!args) SWIG_fail;
14361 swig_obj[0] = args;
14362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14363 if (!SWIG_IsOK(res1)) {
14364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14365 }
14366 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14367 {
14368 PyThreadState* __tstate = wxPyBeginAllowThreads();
14369 result = (int)(arg1)->GetProductId();
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_From_int(static_cast< int >(result));
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14381 PyObject *resultobj = 0;
14382 wxJoystick *arg1 = (wxJoystick *) 0 ;
14383 wxString result;
14384 void *argp1 = 0 ;
14385 int res1 = 0 ;
14386 PyObject *swig_obj[1] ;
14387
14388 if (!args) SWIG_fail;
14389 swig_obj[0] = args;
14390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14391 if (!SWIG_IsOK(res1)) {
14392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14393 }
14394 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (arg1)->GetProductName();
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 {
14402 #if wxUSE_UNICODE
14403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14404 #else
14405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14406 #endif
14407 }
14408 return resultobj;
14409 fail:
14410 return NULL;
14411 }
14412
14413
14414 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14415 PyObject *resultobj = 0;
14416 wxJoystick *arg1 = (wxJoystick *) 0 ;
14417 int result;
14418 void *argp1 = 0 ;
14419 int res1 = 0 ;
14420 PyObject *swig_obj[1] ;
14421
14422 if (!args) SWIG_fail;
14423 swig_obj[0] = args;
14424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14425 if (!SWIG_IsOK(res1)) {
14426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14427 }
14428 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14429 {
14430 PyThreadState* __tstate = wxPyBeginAllowThreads();
14431 result = (int)(arg1)->GetXMin();
14432 wxPyEndAllowThreads(__tstate);
14433 if (PyErr_Occurred()) SWIG_fail;
14434 }
14435 resultobj = SWIG_From_int(static_cast< int >(result));
14436 return resultobj;
14437 fail:
14438 return NULL;
14439 }
14440
14441
14442 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14443 PyObject *resultobj = 0;
14444 wxJoystick *arg1 = (wxJoystick *) 0 ;
14445 int result;
14446 void *argp1 = 0 ;
14447 int res1 = 0 ;
14448 PyObject *swig_obj[1] ;
14449
14450 if (!args) SWIG_fail;
14451 swig_obj[0] = args;
14452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14453 if (!SWIG_IsOK(res1)) {
14454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14455 }
14456 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14457 {
14458 PyThreadState* __tstate = wxPyBeginAllowThreads();
14459 result = (int)(arg1)->GetYMin();
14460 wxPyEndAllowThreads(__tstate);
14461 if (PyErr_Occurred()) SWIG_fail;
14462 }
14463 resultobj = SWIG_From_int(static_cast< int >(result));
14464 return resultobj;
14465 fail:
14466 return NULL;
14467 }
14468
14469
14470 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14471 PyObject *resultobj = 0;
14472 wxJoystick *arg1 = (wxJoystick *) 0 ;
14473 int result;
14474 void *argp1 = 0 ;
14475 int res1 = 0 ;
14476 PyObject *swig_obj[1] ;
14477
14478 if (!args) SWIG_fail;
14479 swig_obj[0] = args;
14480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14481 if (!SWIG_IsOK(res1)) {
14482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14483 }
14484 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14485 {
14486 PyThreadState* __tstate = wxPyBeginAllowThreads();
14487 result = (int)(arg1)->GetZMin();
14488 wxPyEndAllowThreads(__tstate);
14489 if (PyErr_Occurred()) SWIG_fail;
14490 }
14491 resultobj = SWIG_From_int(static_cast< int >(result));
14492 return resultobj;
14493 fail:
14494 return NULL;
14495 }
14496
14497
14498 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14499 PyObject *resultobj = 0;
14500 wxJoystick *arg1 = (wxJoystick *) 0 ;
14501 int result;
14502 void *argp1 = 0 ;
14503 int res1 = 0 ;
14504 PyObject *swig_obj[1] ;
14505
14506 if (!args) SWIG_fail;
14507 swig_obj[0] = args;
14508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14509 if (!SWIG_IsOK(res1)) {
14510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14511 }
14512 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14513 {
14514 PyThreadState* __tstate = wxPyBeginAllowThreads();
14515 result = (int)(arg1)->GetXMax();
14516 wxPyEndAllowThreads(__tstate);
14517 if (PyErr_Occurred()) SWIG_fail;
14518 }
14519 resultobj = SWIG_From_int(static_cast< int >(result));
14520 return resultobj;
14521 fail:
14522 return NULL;
14523 }
14524
14525
14526 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14527 PyObject *resultobj = 0;
14528 wxJoystick *arg1 = (wxJoystick *) 0 ;
14529 int result;
14530 void *argp1 = 0 ;
14531 int res1 = 0 ;
14532 PyObject *swig_obj[1] ;
14533
14534 if (!args) SWIG_fail;
14535 swig_obj[0] = args;
14536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14537 if (!SWIG_IsOK(res1)) {
14538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14539 }
14540 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 result = (int)(arg1)->GetYMax();
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 resultobj = SWIG_From_int(static_cast< int >(result));
14548 return resultobj;
14549 fail:
14550 return NULL;
14551 }
14552
14553
14554 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14555 PyObject *resultobj = 0;
14556 wxJoystick *arg1 = (wxJoystick *) 0 ;
14557 int result;
14558 void *argp1 = 0 ;
14559 int res1 = 0 ;
14560 PyObject *swig_obj[1] ;
14561
14562 if (!args) SWIG_fail;
14563 swig_obj[0] = args;
14564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14565 if (!SWIG_IsOK(res1)) {
14566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14567 }
14568 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 result = (int)(arg1)->GetZMax();
14572 wxPyEndAllowThreads(__tstate);
14573 if (PyErr_Occurred()) SWIG_fail;
14574 }
14575 resultobj = SWIG_From_int(static_cast< int >(result));
14576 return resultobj;
14577 fail:
14578 return NULL;
14579 }
14580
14581
14582 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14583 PyObject *resultobj = 0;
14584 wxJoystick *arg1 = (wxJoystick *) 0 ;
14585 int result;
14586 void *argp1 = 0 ;
14587 int res1 = 0 ;
14588 PyObject *swig_obj[1] ;
14589
14590 if (!args) SWIG_fail;
14591 swig_obj[0] = args;
14592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14593 if (!SWIG_IsOK(res1)) {
14594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14595 }
14596 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 result = (int)(arg1)->GetNumberButtons();
14600 wxPyEndAllowThreads(__tstate);
14601 if (PyErr_Occurred()) SWIG_fail;
14602 }
14603 resultobj = SWIG_From_int(static_cast< int >(result));
14604 return resultobj;
14605 fail:
14606 return NULL;
14607 }
14608
14609
14610 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14611 PyObject *resultobj = 0;
14612 wxJoystick *arg1 = (wxJoystick *) 0 ;
14613 int result;
14614 void *argp1 = 0 ;
14615 int res1 = 0 ;
14616 PyObject *swig_obj[1] ;
14617
14618 if (!args) SWIG_fail;
14619 swig_obj[0] = args;
14620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14621 if (!SWIG_IsOK(res1)) {
14622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14623 }
14624 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14625 {
14626 PyThreadState* __tstate = wxPyBeginAllowThreads();
14627 result = (int)(arg1)->GetNumberAxes();
14628 wxPyEndAllowThreads(__tstate);
14629 if (PyErr_Occurred()) SWIG_fail;
14630 }
14631 resultobj = SWIG_From_int(static_cast< int >(result));
14632 return resultobj;
14633 fail:
14634 return NULL;
14635 }
14636
14637
14638 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14639 PyObject *resultobj = 0;
14640 wxJoystick *arg1 = (wxJoystick *) 0 ;
14641 int result;
14642 void *argp1 = 0 ;
14643 int res1 = 0 ;
14644 PyObject *swig_obj[1] ;
14645
14646 if (!args) SWIG_fail;
14647 swig_obj[0] = args;
14648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14649 if (!SWIG_IsOK(res1)) {
14650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14651 }
14652 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14653 {
14654 PyThreadState* __tstate = wxPyBeginAllowThreads();
14655 result = (int)(arg1)->GetMaxButtons();
14656 wxPyEndAllowThreads(__tstate);
14657 if (PyErr_Occurred()) SWIG_fail;
14658 }
14659 resultobj = SWIG_From_int(static_cast< int >(result));
14660 return resultobj;
14661 fail:
14662 return NULL;
14663 }
14664
14665
14666 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14667 PyObject *resultobj = 0;
14668 wxJoystick *arg1 = (wxJoystick *) 0 ;
14669 int result;
14670 void *argp1 = 0 ;
14671 int res1 = 0 ;
14672 PyObject *swig_obj[1] ;
14673
14674 if (!args) SWIG_fail;
14675 swig_obj[0] = args;
14676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14677 if (!SWIG_IsOK(res1)) {
14678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14679 }
14680 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14681 {
14682 PyThreadState* __tstate = wxPyBeginAllowThreads();
14683 result = (int)(arg1)->GetMaxAxes();
14684 wxPyEndAllowThreads(__tstate);
14685 if (PyErr_Occurred()) SWIG_fail;
14686 }
14687 resultobj = SWIG_From_int(static_cast< int >(result));
14688 return resultobj;
14689 fail:
14690 return NULL;
14691 }
14692
14693
14694 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14695 PyObject *resultobj = 0;
14696 wxJoystick *arg1 = (wxJoystick *) 0 ;
14697 int result;
14698 void *argp1 = 0 ;
14699 int res1 = 0 ;
14700 PyObject *swig_obj[1] ;
14701
14702 if (!args) SWIG_fail;
14703 swig_obj[0] = args;
14704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14705 if (!SWIG_IsOK(res1)) {
14706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14707 }
14708 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 result = (int)(arg1)->GetPollingMin();
14712 wxPyEndAllowThreads(__tstate);
14713 if (PyErr_Occurred()) SWIG_fail;
14714 }
14715 resultobj = SWIG_From_int(static_cast< int >(result));
14716 return resultobj;
14717 fail:
14718 return NULL;
14719 }
14720
14721
14722 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14723 PyObject *resultobj = 0;
14724 wxJoystick *arg1 = (wxJoystick *) 0 ;
14725 int result;
14726 void *argp1 = 0 ;
14727 int res1 = 0 ;
14728 PyObject *swig_obj[1] ;
14729
14730 if (!args) SWIG_fail;
14731 swig_obj[0] = args;
14732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14733 if (!SWIG_IsOK(res1)) {
14734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14735 }
14736 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14737 {
14738 PyThreadState* __tstate = wxPyBeginAllowThreads();
14739 result = (int)(arg1)->GetPollingMax();
14740 wxPyEndAllowThreads(__tstate);
14741 if (PyErr_Occurred()) SWIG_fail;
14742 }
14743 resultobj = SWIG_From_int(static_cast< int >(result));
14744 return resultobj;
14745 fail:
14746 return NULL;
14747 }
14748
14749
14750 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14751 PyObject *resultobj = 0;
14752 wxJoystick *arg1 = (wxJoystick *) 0 ;
14753 int result;
14754 void *argp1 = 0 ;
14755 int res1 = 0 ;
14756 PyObject *swig_obj[1] ;
14757
14758 if (!args) SWIG_fail;
14759 swig_obj[0] = args;
14760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14761 if (!SWIG_IsOK(res1)) {
14762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14763 }
14764 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14765 {
14766 PyThreadState* __tstate = wxPyBeginAllowThreads();
14767 result = (int)(arg1)->GetRudderMin();
14768 wxPyEndAllowThreads(__tstate);
14769 if (PyErr_Occurred()) SWIG_fail;
14770 }
14771 resultobj = SWIG_From_int(static_cast< int >(result));
14772 return resultobj;
14773 fail:
14774 return NULL;
14775 }
14776
14777
14778 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14779 PyObject *resultobj = 0;
14780 wxJoystick *arg1 = (wxJoystick *) 0 ;
14781 int result;
14782 void *argp1 = 0 ;
14783 int res1 = 0 ;
14784 PyObject *swig_obj[1] ;
14785
14786 if (!args) SWIG_fail;
14787 swig_obj[0] = args;
14788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14789 if (!SWIG_IsOK(res1)) {
14790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14791 }
14792 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 result = (int)(arg1)->GetRudderMax();
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 resultobj = SWIG_From_int(static_cast< int >(result));
14800 return resultobj;
14801 fail:
14802 return NULL;
14803 }
14804
14805
14806 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14807 PyObject *resultobj = 0;
14808 wxJoystick *arg1 = (wxJoystick *) 0 ;
14809 int result;
14810 void *argp1 = 0 ;
14811 int res1 = 0 ;
14812 PyObject *swig_obj[1] ;
14813
14814 if (!args) SWIG_fail;
14815 swig_obj[0] = args;
14816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14817 if (!SWIG_IsOK(res1)) {
14818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14819 }
14820 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14821 {
14822 PyThreadState* __tstate = wxPyBeginAllowThreads();
14823 result = (int)(arg1)->GetUMin();
14824 wxPyEndAllowThreads(__tstate);
14825 if (PyErr_Occurred()) SWIG_fail;
14826 }
14827 resultobj = SWIG_From_int(static_cast< int >(result));
14828 return resultobj;
14829 fail:
14830 return NULL;
14831 }
14832
14833
14834 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14835 PyObject *resultobj = 0;
14836 wxJoystick *arg1 = (wxJoystick *) 0 ;
14837 int result;
14838 void *argp1 = 0 ;
14839 int res1 = 0 ;
14840 PyObject *swig_obj[1] ;
14841
14842 if (!args) SWIG_fail;
14843 swig_obj[0] = args;
14844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14845 if (!SWIG_IsOK(res1)) {
14846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14847 }
14848 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 result = (int)(arg1)->GetUMax();
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 resultobj = SWIG_From_int(static_cast< int >(result));
14856 return resultobj;
14857 fail:
14858 return NULL;
14859 }
14860
14861
14862 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14863 PyObject *resultobj = 0;
14864 wxJoystick *arg1 = (wxJoystick *) 0 ;
14865 int result;
14866 void *argp1 = 0 ;
14867 int res1 = 0 ;
14868 PyObject *swig_obj[1] ;
14869
14870 if (!args) SWIG_fail;
14871 swig_obj[0] = args;
14872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14873 if (!SWIG_IsOK(res1)) {
14874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14875 }
14876 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14877 {
14878 PyThreadState* __tstate = wxPyBeginAllowThreads();
14879 result = (int)(arg1)->GetVMin();
14880 wxPyEndAllowThreads(__tstate);
14881 if (PyErr_Occurred()) SWIG_fail;
14882 }
14883 resultobj = SWIG_From_int(static_cast< int >(result));
14884 return resultobj;
14885 fail:
14886 return NULL;
14887 }
14888
14889
14890 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14891 PyObject *resultobj = 0;
14892 wxJoystick *arg1 = (wxJoystick *) 0 ;
14893 int result;
14894 void *argp1 = 0 ;
14895 int res1 = 0 ;
14896 PyObject *swig_obj[1] ;
14897
14898 if (!args) SWIG_fail;
14899 swig_obj[0] = args;
14900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14901 if (!SWIG_IsOK(res1)) {
14902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14903 }
14904 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14905 {
14906 PyThreadState* __tstate = wxPyBeginAllowThreads();
14907 result = (int)(arg1)->GetVMax();
14908 wxPyEndAllowThreads(__tstate);
14909 if (PyErr_Occurred()) SWIG_fail;
14910 }
14911 resultobj = SWIG_From_int(static_cast< int >(result));
14912 return resultobj;
14913 fail:
14914 return NULL;
14915 }
14916
14917
14918 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14919 PyObject *resultobj = 0;
14920 wxJoystick *arg1 = (wxJoystick *) 0 ;
14921 bool result;
14922 void *argp1 = 0 ;
14923 int res1 = 0 ;
14924 PyObject *swig_obj[1] ;
14925
14926 if (!args) SWIG_fail;
14927 swig_obj[0] = args;
14928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14929 if (!SWIG_IsOK(res1)) {
14930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14931 }
14932 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 result = (bool)(arg1)->HasRudder();
14936 wxPyEndAllowThreads(__tstate);
14937 if (PyErr_Occurred()) SWIG_fail;
14938 }
14939 {
14940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14941 }
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14949 PyObject *resultobj = 0;
14950 wxJoystick *arg1 = (wxJoystick *) 0 ;
14951 bool result;
14952 void *argp1 = 0 ;
14953 int res1 = 0 ;
14954 PyObject *swig_obj[1] ;
14955
14956 if (!args) SWIG_fail;
14957 swig_obj[0] = args;
14958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14959 if (!SWIG_IsOK(res1)) {
14960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14961 }
14962 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14963 {
14964 PyThreadState* __tstate = wxPyBeginAllowThreads();
14965 result = (bool)(arg1)->HasZ();
14966 wxPyEndAllowThreads(__tstate);
14967 if (PyErr_Occurred()) SWIG_fail;
14968 }
14969 {
14970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14971 }
14972 return resultobj;
14973 fail:
14974 return NULL;
14975 }
14976
14977
14978 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14979 PyObject *resultobj = 0;
14980 wxJoystick *arg1 = (wxJoystick *) 0 ;
14981 bool result;
14982 void *argp1 = 0 ;
14983 int res1 = 0 ;
14984 PyObject *swig_obj[1] ;
14985
14986 if (!args) SWIG_fail;
14987 swig_obj[0] = args;
14988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14989 if (!SWIG_IsOK(res1)) {
14990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14991 }
14992 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14993 {
14994 PyThreadState* __tstate = wxPyBeginAllowThreads();
14995 result = (bool)(arg1)->HasU();
14996 wxPyEndAllowThreads(__tstate);
14997 if (PyErr_Occurred()) SWIG_fail;
14998 }
14999 {
15000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15001 }
15002 return resultobj;
15003 fail:
15004 return NULL;
15005 }
15006
15007
15008 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15009 PyObject *resultobj = 0;
15010 wxJoystick *arg1 = (wxJoystick *) 0 ;
15011 bool result;
15012 void *argp1 = 0 ;
15013 int res1 = 0 ;
15014 PyObject *swig_obj[1] ;
15015
15016 if (!args) SWIG_fail;
15017 swig_obj[0] = args;
15018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15019 if (!SWIG_IsOK(res1)) {
15020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15021 }
15022 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15023 {
15024 PyThreadState* __tstate = wxPyBeginAllowThreads();
15025 result = (bool)(arg1)->HasV();
15026 wxPyEndAllowThreads(__tstate);
15027 if (PyErr_Occurred()) SWIG_fail;
15028 }
15029 {
15030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15031 }
15032 return resultobj;
15033 fail:
15034 return NULL;
15035 }
15036
15037
15038 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15039 PyObject *resultobj = 0;
15040 wxJoystick *arg1 = (wxJoystick *) 0 ;
15041 bool result;
15042 void *argp1 = 0 ;
15043 int res1 = 0 ;
15044 PyObject *swig_obj[1] ;
15045
15046 if (!args) SWIG_fail;
15047 swig_obj[0] = args;
15048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15049 if (!SWIG_IsOK(res1)) {
15050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15051 }
15052 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15053 {
15054 PyThreadState* __tstate = wxPyBeginAllowThreads();
15055 result = (bool)(arg1)->HasPOV();
15056 wxPyEndAllowThreads(__tstate);
15057 if (PyErr_Occurred()) SWIG_fail;
15058 }
15059 {
15060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15061 }
15062 return resultobj;
15063 fail:
15064 return NULL;
15065 }
15066
15067
15068 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15069 PyObject *resultobj = 0;
15070 wxJoystick *arg1 = (wxJoystick *) 0 ;
15071 bool result;
15072 void *argp1 = 0 ;
15073 int res1 = 0 ;
15074 PyObject *swig_obj[1] ;
15075
15076 if (!args) SWIG_fail;
15077 swig_obj[0] = args;
15078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15079 if (!SWIG_IsOK(res1)) {
15080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15081 }
15082 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 result = (bool)(arg1)->HasPOV4Dir();
15086 wxPyEndAllowThreads(__tstate);
15087 if (PyErr_Occurred()) SWIG_fail;
15088 }
15089 {
15090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15091 }
15092 return resultobj;
15093 fail:
15094 return NULL;
15095 }
15096
15097
15098 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15099 PyObject *resultobj = 0;
15100 wxJoystick *arg1 = (wxJoystick *) 0 ;
15101 bool result;
15102 void *argp1 = 0 ;
15103 int res1 = 0 ;
15104 PyObject *swig_obj[1] ;
15105
15106 if (!args) SWIG_fail;
15107 swig_obj[0] = args;
15108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15109 if (!SWIG_IsOK(res1)) {
15110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15111 }
15112 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15113 {
15114 PyThreadState* __tstate = wxPyBeginAllowThreads();
15115 result = (bool)(arg1)->HasPOVCTS();
15116 wxPyEndAllowThreads(__tstate);
15117 if (PyErr_Occurred()) SWIG_fail;
15118 }
15119 {
15120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15121 }
15122 return resultobj;
15123 fail:
15124 return NULL;
15125 }
15126
15127
15128 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15129 PyObject *resultobj = 0;
15130 wxJoystick *arg1 = (wxJoystick *) 0 ;
15131 wxWindow *arg2 = (wxWindow *) 0 ;
15132 int arg3 = (int) 0 ;
15133 bool result;
15134 void *argp1 = 0 ;
15135 int res1 = 0 ;
15136 void *argp2 = 0 ;
15137 int res2 = 0 ;
15138 int val3 ;
15139 int ecode3 = 0 ;
15140 PyObject * obj0 = 0 ;
15141 PyObject * obj1 = 0 ;
15142 PyObject * obj2 = 0 ;
15143 char * kwnames[] = {
15144 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15145 };
15146
15147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15149 if (!SWIG_IsOK(res1)) {
15150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15151 }
15152 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15154 if (!SWIG_IsOK(res2)) {
15155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15156 }
15157 arg2 = reinterpret_cast< wxWindow * >(argp2);
15158 if (obj2) {
15159 ecode3 = SWIG_AsVal_int(obj2, &val3);
15160 if (!SWIG_IsOK(ecode3)) {
15161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15162 }
15163 arg3 = static_cast< int >(val3);
15164 }
15165 {
15166 PyThreadState* __tstate = wxPyBeginAllowThreads();
15167 result = (bool)(arg1)->SetCapture(arg2,arg3);
15168 wxPyEndAllowThreads(__tstate);
15169 if (PyErr_Occurred()) SWIG_fail;
15170 }
15171 {
15172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15173 }
15174 return resultobj;
15175 fail:
15176 return NULL;
15177 }
15178
15179
15180 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15181 PyObject *resultobj = 0;
15182 wxJoystick *arg1 = (wxJoystick *) 0 ;
15183 bool result;
15184 void *argp1 = 0 ;
15185 int res1 = 0 ;
15186 PyObject *swig_obj[1] ;
15187
15188 if (!args) SWIG_fail;
15189 swig_obj[0] = args;
15190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15191 if (!SWIG_IsOK(res1)) {
15192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15193 }
15194 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15195 {
15196 PyThreadState* __tstate = wxPyBeginAllowThreads();
15197 result = (bool)(arg1)->ReleaseCapture();
15198 wxPyEndAllowThreads(__tstate);
15199 if (PyErr_Occurred()) SWIG_fail;
15200 }
15201 {
15202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15203 }
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15211 PyObject *obj;
15212 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15213 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15214 return SWIG_Py_Void();
15215 }
15216
15217 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15218 return SWIG_Python_InitShadowInstance(args);
15219 }
15220
15221 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15222 PyObject *resultobj = 0;
15223 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15224 int arg2 = (int) 0 ;
15225 int arg3 = (int) wxJOYSTICK1 ;
15226 int arg4 = (int) 0 ;
15227 wxJoystickEvent *result = 0 ;
15228 int val1 ;
15229 int ecode1 = 0 ;
15230 int val2 ;
15231 int ecode2 = 0 ;
15232 int val3 ;
15233 int ecode3 = 0 ;
15234 int val4 ;
15235 int ecode4 = 0 ;
15236 PyObject * obj0 = 0 ;
15237 PyObject * obj1 = 0 ;
15238 PyObject * obj2 = 0 ;
15239 PyObject * obj3 = 0 ;
15240 char * kwnames[] = {
15241 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15242 };
15243
15244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15245 if (obj0) {
15246 ecode1 = SWIG_AsVal_int(obj0, &val1);
15247 if (!SWIG_IsOK(ecode1)) {
15248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15249 }
15250 arg1 = static_cast< wxEventType >(val1);
15251 }
15252 if (obj1) {
15253 ecode2 = SWIG_AsVal_int(obj1, &val2);
15254 if (!SWIG_IsOK(ecode2)) {
15255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15256 }
15257 arg2 = static_cast< int >(val2);
15258 }
15259 if (obj2) {
15260 ecode3 = SWIG_AsVal_int(obj2, &val3);
15261 if (!SWIG_IsOK(ecode3)) {
15262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15263 }
15264 arg3 = static_cast< int >(val3);
15265 }
15266 if (obj3) {
15267 ecode4 = SWIG_AsVal_int(obj3, &val4);
15268 if (!SWIG_IsOK(ecode4)) {
15269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15270 }
15271 arg4 = static_cast< int >(val4);
15272 }
15273 {
15274 PyThreadState* __tstate = wxPyBeginAllowThreads();
15275 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15276 wxPyEndAllowThreads(__tstate);
15277 if (PyErr_Occurred()) SWIG_fail;
15278 }
15279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15287 PyObject *resultobj = 0;
15288 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15289 wxPoint result;
15290 void *argp1 = 0 ;
15291 int res1 = 0 ;
15292 PyObject *swig_obj[1] ;
15293
15294 if (!args) SWIG_fail;
15295 swig_obj[0] = args;
15296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15297 if (!SWIG_IsOK(res1)) {
15298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15299 }
15300 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15301 {
15302 PyThreadState* __tstate = wxPyBeginAllowThreads();
15303 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15315 PyObject *resultobj = 0;
15316 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15317 int result;
15318 void *argp1 = 0 ;
15319 int res1 = 0 ;
15320 PyObject *swig_obj[1] ;
15321
15322 if (!args) SWIG_fail;
15323 swig_obj[0] = args;
15324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15325 if (!SWIG_IsOK(res1)) {
15326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15327 }
15328 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15329 {
15330 PyThreadState* __tstate = wxPyBeginAllowThreads();
15331 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15332 wxPyEndAllowThreads(__tstate);
15333 if (PyErr_Occurred()) SWIG_fail;
15334 }
15335 resultobj = SWIG_From_int(static_cast< int >(result));
15336 return resultobj;
15337 fail:
15338 return NULL;
15339 }
15340
15341
15342 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15343 PyObject *resultobj = 0;
15344 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15345 int result;
15346 void *argp1 = 0 ;
15347 int res1 = 0 ;
15348 PyObject *swig_obj[1] ;
15349
15350 if (!args) SWIG_fail;
15351 swig_obj[0] = args;
15352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15353 if (!SWIG_IsOK(res1)) {
15354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15355 }
15356 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15357 {
15358 PyThreadState* __tstate = wxPyBeginAllowThreads();
15359 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15360 wxPyEndAllowThreads(__tstate);
15361 if (PyErr_Occurred()) SWIG_fail;
15362 }
15363 resultobj = SWIG_From_int(static_cast< int >(result));
15364 return resultobj;
15365 fail:
15366 return NULL;
15367 }
15368
15369
15370 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15371 PyObject *resultobj = 0;
15372 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15373 int result;
15374 void *argp1 = 0 ;
15375 int res1 = 0 ;
15376 PyObject *swig_obj[1] ;
15377
15378 if (!args) SWIG_fail;
15379 swig_obj[0] = args;
15380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15381 if (!SWIG_IsOK(res1)) {
15382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15383 }
15384 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15385 {
15386 PyThreadState* __tstate = wxPyBeginAllowThreads();
15387 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15388 wxPyEndAllowThreads(__tstate);
15389 if (PyErr_Occurred()) SWIG_fail;
15390 }
15391 resultobj = SWIG_From_int(static_cast< int >(result));
15392 return resultobj;
15393 fail:
15394 return NULL;
15395 }
15396
15397
15398 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15399 PyObject *resultobj = 0;
15400 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15401 int result;
15402 void *argp1 = 0 ;
15403 int res1 = 0 ;
15404 PyObject *swig_obj[1] ;
15405
15406 if (!args) SWIG_fail;
15407 swig_obj[0] = args;
15408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15411 }
15412 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15413 {
15414 PyThreadState* __tstate = wxPyBeginAllowThreads();
15415 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15416 wxPyEndAllowThreads(__tstate);
15417 if (PyErr_Occurred()) SWIG_fail;
15418 }
15419 resultobj = SWIG_From_int(static_cast< int >(result));
15420 return resultobj;
15421 fail:
15422 return NULL;
15423 }
15424
15425
15426 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15427 PyObject *resultobj = 0;
15428 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15429 int arg2 ;
15430 void *argp1 = 0 ;
15431 int res1 = 0 ;
15432 int val2 ;
15433 int ecode2 = 0 ;
15434 PyObject * obj0 = 0 ;
15435 PyObject * obj1 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "self",(char *) "stick", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15444 }
15445 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15446 ecode2 = SWIG_AsVal_int(obj1, &val2);
15447 if (!SWIG_IsOK(ecode2)) {
15448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15449 }
15450 arg2 = static_cast< int >(val2);
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 (arg1)->SetJoystick(arg2);
15454 wxPyEndAllowThreads(__tstate);
15455 if (PyErr_Occurred()) SWIG_fail;
15456 }
15457 resultobj = SWIG_Py_Void();
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15465 PyObject *resultobj = 0;
15466 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15467 int arg2 ;
15468 void *argp1 = 0 ;
15469 int res1 = 0 ;
15470 int val2 ;
15471 int ecode2 = 0 ;
15472 PyObject * obj0 = 0 ;
15473 PyObject * obj1 = 0 ;
15474 char * kwnames[] = {
15475 (char *) "self",(char *) "state", NULL
15476 };
15477
15478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15480 if (!SWIG_IsOK(res1)) {
15481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15482 }
15483 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15484 ecode2 = SWIG_AsVal_int(obj1, &val2);
15485 if (!SWIG_IsOK(ecode2)) {
15486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15487 }
15488 arg2 = static_cast< int >(val2);
15489 {
15490 PyThreadState* __tstate = wxPyBeginAllowThreads();
15491 (arg1)->SetButtonState(arg2);
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 resultobj = SWIG_Py_Void();
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15503 PyObject *resultobj = 0;
15504 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15505 int arg2 ;
15506 void *argp1 = 0 ;
15507 int res1 = 0 ;
15508 int val2 ;
15509 int ecode2 = 0 ;
15510 PyObject * obj0 = 0 ;
15511 PyObject * obj1 = 0 ;
15512 char * kwnames[] = {
15513 (char *) "self",(char *) "change", NULL
15514 };
15515
15516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15520 }
15521 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15522 ecode2 = SWIG_AsVal_int(obj1, &val2);
15523 if (!SWIG_IsOK(ecode2)) {
15524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15525 }
15526 arg2 = static_cast< int >(val2);
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 (arg1)->SetButtonChange(arg2);
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 resultobj = SWIG_Py_Void();
15534 return resultobj;
15535 fail:
15536 return NULL;
15537 }
15538
15539
15540 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15541 PyObject *resultobj = 0;
15542 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15543 wxPoint *arg2 = 0 ;
15544 void *argp1 = 0 ;
15545 int res1 = 0 ;
15546 wxPoint temp2 ;
15547 PyObject * obj0 = 0 ;
15548 PyObject * obj1 = 0 ;
15549 char * kwnames[] = {
15550 (char *) "self",(char *) "pos", NULL
15551 };
15552
15553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15555 if (!SWIG_IsOK(res1)) {
15556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15557 }
15558 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15559 {
15560 arg2 = &temp2;
15561 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15562 }
15563 {
15564 PyThreadState* __tstate = wxPyBeginAllowThreads();
15565 (arg1)->SetPosition((wxPoint const &)*arg2);
15566 wxPyEndAllowThreads(__tstate);
15567 if (PyErr_Occurred()) SWIG_fail;
15568 }
15569 resultobj = SWIG_Py_Void();
15570 return resultobj;
15571 fail:
15572 return NULL;
15573 }
15574
15575
15576 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15577 PyObject *resultobj = 0;
15578 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15579 int arg2 ;
15580 void *argp1 = 0 ;
15581 int res1 = 0 ;
15582 int val2 ;
15583 int ecode2 = 0 ;
15584 PyObject * obj0 = 0 ;
15585 PyObject * obj1 = 0 ;
15586 char * kwnames[] = {
15587 (char *) "self",(char *) "zPos", NULL
15588 };
15589
15590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15592 if (!SWIG_IsOK(res1)) {
15593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15594 }
15595 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15596 ecode2 = SWIG_AsVal_int(obj1, &val2);
15597 if (!SWIG_IsOK(ecode2)) {
15598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15599 }
15600 arg2 = static_cast< int >(val2);
15601 {
15602 PyThreadState* __tstate = wxPyBeginAllowThreads();
15603 (arg1)->SetZPosition(arg2);
15604 wxPyEndAllowThreads(__tstate);
15605 if (PyErr_Occurred()) SWIG_fail;
15606 }
15607 resultobj = SWIG_Py_Void();
15608 return resultobj;
15609 fail:
15610 return NULL;
15611 }
15612
15613
15614 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15615 PyObject *resultobj = 0;
15616 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15617 bool result;
15618 void *argp1 = 0 ;
15619 int res1 = 0 ;
15620 PyObject *swig_obj[1] ;
15621
15622 if (!args) SWIG_fail;
15623 swig_obj[0] = args;
15624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15625 if (!SWIG_IsOK(res1)) {
15626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15627 }
15628 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 {
15636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15637 }
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15645 PyObject *resultobj = 0;
15646 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15647 bool result;
15648 void *argp1 = 0 ;
15649 int res1 = 0 ;
15650 PyObject *swig_obj[1] ;
15651
15652 if (!args) SWIG_fail;
15653 swig_obj[0] = args;
15654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15655 if (!SWIG_IsOK(res1)) {
15656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15657 }
15658 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15659 {
15660 PyThreadState* __tstate = wxPyBeginAllowThreads();
15661 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15662 wxPyEndAllowThreads(__tstate);
15663 if (PyErr_Occurred()) SWIG_fail;
15664 }
15665 {
15666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15667 }
15668 return resultobj;
15669 fail:
15670 return NULL;
15671 }
15672
15673
15674 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15675 PyObject *resultobj = 0;
15676 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15677 bool result;
15678 void *argp1 = 0 ;
15679 int res1 = 0 ;
15680 PyObject *swig_obj[1] ;
15681
15682 if (!args) SWIG_fail;
15683 swig_obj[0] = args;
15684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15685 if (!SWIG_IsOK(res1)) {
15686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15687 }
15688 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15689 {
15690 PyThreadState* __tstate = wxPyBeginAllowThreads();
15691 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15692 wxPyEndAllowThreads(__tstate);
15693 if (PyErr_Occurred()) SWIG_fail;
15694 }
15695 {
15696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15697 }
15698 return resultobj;
15699 fail:
15700 return NULL;
15701 }
15702
15703
15704 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15705 PyObject *resultobj = 0;
15706 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15707 int arg2 = (int) wxJOY_BUTTON_ANY ;
15708 bool result;
15709 void *argp1 = 0 ;
15710 int res1 = 0 ;
15711 int val2 ;
15712 int ecode2 = 0 ;
15713 PyObject * obj0 = 0 ;
15714 PyObject * obj1 = 0 ;
15715 char * kwnames[] = {
15716 (char *) "self",(char *) "but", NULL
15717 };
15718
15719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15721 if (!SWIG_IsOK(res1)) {
15722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15723 }
15724 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15725 if (obj1) {
15726 ecode2 = SWIG_AsVal_int(obj1, &val2);
15727 if (!SWIG_IsOK(ecode2)) {
15728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15729 }
15730 arg2 = static_cast< int >(val2);
15731 }
15732 {
15733 PyThreadState* __tstate = wxPyBeginAllowThreads();
15734 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15735 wxPyEndAllowThreads(__tstate);
15736 if (PyErr_Occurred()) SWIG_fail;
15737 }
15738 {
15739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15740 }
15741 return resultobj;
15742 fail:
15743 return NULL;
15744 }
15745
15746
15747 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15748 PyObject *resultobj = 0;
15749 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15750 int arg2 = (int) wxJOY_BUTTON_ANY ;
15751 bool result;
15752 void *argp1 = 0 ;
15753 int res1 = 0 ;
15754 int val2 ;
15755 int ecode2 = 0 ;
15756 PyObject * obj0 = 0 ;
15757 PyObject * obj1 = 0 ;
15758 char * kwnames[] = {
15759 (char *) "self",(char *) "but", NULL
15760 };
15761
15762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15766 }
15767 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15768 if (obj1) {
15769 ecode2 = SWIG_AsVal_int(obj1, &val2);
15770 if (!SWIG_IsOK(ecode2)) {
15771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15772 }
15773 arg2 = static_cast< int >(val2);
15774 }
15775 {
15776 PyThreadState* __tstate = wxPyBeginAllowThreads();
15777 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15778 wxPyEndAllowThreads(__tstate);
15779 if (PyErr_Occurred()) SWIG_fail;
15780 }
15781 {
15782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15783 }
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15791 PyObject *resultobj = 0;
15792 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15793 int arg2 = (int) wxJOY_BUTTON_ANY ;
15794 bool result;
15795 void *argp1 = 0 ;
15796 int res1 = 0 ;
15797 int val2 ;
15798 int ecode2 = 0 ;
15799 PyObject * obj0 = 0 ;
15800 PyObject * obj1 = 0 ;
15801 char * kwnames[] = {
15802 (char *) "self",(char *) "but", NULL
15803 };
15804
15805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15807 if (!SWIG_IsOK(res1)) {
15808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15809 }
15810 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15811 if (obj1) {
15812 ecode2 = SWIG_AsVal_int(obj1, &val2);
15813 if (!SWIG_IsOK(ecode2)) {
15814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15815 }
15816 arg2 = static_cast< int >(val2);
15817 }
15818 {
15819 PyThreadState* __tstate = wxPyBeginAllowThreads();
15820 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15821 wxPyEndAllowThreads(__tstate);
15822 if (PyErr_Occurred()) SWIG_fail;
15823 }
15824 {
15825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15826 }
15827 return resultobj;
15828 fail:
15829 return NULL;
15830 }
15831
15832
15833 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15834 PyObject *obj;
15835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15836 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15837 return SWIG_Py_Void();
15838 }
15839
15840 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15841 return SWIG_Python_InitShadowInstance(args);
15842 }
15843
15844 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15845 PyObject *resultobj = 0;
15846 wxString const &arg1_defvalue = wxPyEmptyString ;
15847 wxString *arg1 = (wxString *) &arg1_defvalue ;
15848 wxSound *result = 0 ;
15849 bool temp1 = false ;
15850 PyObject * obj0 = 0 ;
15851 char * kwnames[] = {
15852 (char *) "fileName", NULL
15853 };
15854
15855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15856 if (obj0) {
15857 {
15858 arg1 = wxString_in_helper(obj0);
15859 if (arg1 == NULL) SWIG_fail;
15860 temp1 = true;
15861 }
15862 }
15863 {
15864 if (!wxPyCheckForApp()) SWIG_fail;
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15871 {
15872 if (temp1)
15873 delete arg1;
15874 }
15875 return resultobj;
15876 fail:
15877 {
15878 if (temp1)
15879 delete arg1;
15880 }
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15886 PyObject *resultobj = 0;
15887 PyObject *arg1 = (PyObject *) 0 ;
15888 wxSound *result = 0 ;
15889 PyObject * obj0 = 0 ;
15890 char * kwnames[] = {
15891 (char *) "data", NULL
15892 };
15893
15894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15895 arg1 = obj0;
15896 {
15897 if (!wxPyCheckForApp()) SWIG_fail;
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (wxSound *)new_wxSound(arg1);
15900 wxPyEndAllowThreads(__tstate);
15901 if (PyErr_Occurred()) SWIG_fail;
15902 }
15903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15904 return resultobj;
15905 fail:
15906 return NULL;
15907 }
15908
15909
15910 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15911 PyObject *resultobj = 0;
15912 wxSound *arg1 = (wxSound *) 0 ;
15913 void *argp1 = 0 ;
15914 int res1 = 0 ;
15915 PyObject *swig_obj[1] ;
15916
15917 if (!args) SWIG_fail;
15918 swig_obj[0] = args;
15919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15920 if (!SWIG_IsOK(res1)) {
15921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15922 }
15923 arg1 = reinterpret_cast< wxSound * >(argp1);
15924 {
15925 PyThreadState* __tstate = wxPyBeginAllowThreads();
15926 delete arg1;
15927
15928 wxPyEndAllowThreads(__tstate);
15929 if (PyErr_Occurred()) SWIG_fail;
15930 }
15931 resultobj = SWIG_Py_Void();
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15939 PyObject *resultobj = 0;
15940 wxSound *arg1 = (wxSound *) 0 ;
15941 wxString *arg2 = 0 ;
15942 bool result;
15943 void *argp1 = 0 ;
15944 int res1 = 0 ;
15945 bool temp2 = false ;
15946 PyObject * obj0 = 0 ;
15947 PyObject * obj1 = 0 ;
15948 char * kwnames[] = {
15949 (char *) "self",(char *) "fileName", NULL
15950 };
15951
15952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15954 if (!SWIG_IsOK(res1)) {
15955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15956 }
15957 arg1 = reinterpret_cast< wxSound * >(argp1);
15958 {
15959 arg2 = wxString_in_helper(obj1);
15960 if (arg2 == NULL) SWIG_fail;
15961 temp2 = true;
15962 }
15963 {
15964 PyThreadState* __tstate = wxPyBeginAllowThreads();
15965 result = (bool)(arg1)->Create((wxString const &)*arg2);
15966 wxPyEndAllowThreads(__tstate);
15967 if (PyErr_Occurred()) SWIG_fail;
15968 }
15969 {
15970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15971 }
15972 {
15973 if (temp2)
15974 delete arg2;
15975 }
15976 return resultobj;
15977 fail:
15978 {
15979 if (temp2)
15980 delete arg2;
15981 }
15982 return NULL;
15983 }
15984
15985
15986 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15987 PyObject *resultobj = 0;
15988 wxSound *arg1 = (wxSound *) 0 ;
15989 PyObject *arg2 = (PyObject *) 0 ;
15990 bool result;
15991 void *argp1 = 0 ;
15992 int res1 = 0 ;
15993 PyObject * obj0 = 0 ;
15994 PyObject * obj1 = 0 ;
15995 char * kwnames[] = {
15996 (char *) "self",(char *) "data", NULL
15997 };
15998
15999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16001 if (!SWIG_IsOK(res1)) {
16002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16003 }
16004 arg1 = reinterpret_cast< wxSound * >(argp1);
16005 arg2 = obj1;
16006 {
16007 PyThreadState* __tstate = wxPyBeginAllowThreads();
16008 result = (bool)wxSound_CreateFromData(arg1,arg2);
16009 wxPyEndAllowThreads(__tstate);
16010 if (PyErr_Occurred()) SWIG_fail;
16011 }
16012 {
16013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16014 }
16015 return resultobj;
16016 fail:
16017 return NULL;
16018 }
16019
16020
16021 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16022 PyObject *resultobj = 0;
16023 wxSound *arg1 = (wxSound *) 0 ;
16024 bool result;
16025 void *argp1 = 0 ;
16026 int res1 = 0 ;
16027 PyObject *swig_obj[1] ;
16028
16029 if (!args) SWIG_fail;
16030 swig_obj[0] = args;
16031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16032 if (!SWIG_IsOK(res1)) {
16033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16034 }
16035 arg1 = reinterpret_cast< wxSound * >(argp1);
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 result = (bool)(arg1)->IsOk();
16039 wxPyEndAllowThreads(__tstate);
16040 if (PyErr_Occurred()) SWIG_fail;
16041 }
16042 {
16043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16044 }
16045 return resultobj;
16046 fail:
16047 return NULL;
16048 }
16049
16050
16051 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16052 PyObject *resultobj = 0;
16053 wxSound *arg1 = (wxSound *) 0 ;
16054 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16055 bool result;
16056 void *argp1 = 0 ;
16057 int res1 = 0 ;
16058 unsigned int val2 ;
16059 int ecode2 = 0 ;
16060 PyObject * obj0 = 0 ;
16061 PyObject * obj1 = 0 ;
16062 char * kwnames[] = {
16063 (char *) "self",(char *) "flags", NULL
16064 };
16065
16066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16068 if (!SWIG_IsOK(res1)) {
16069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16070 }
16071 arg1 = reinterpret_cast< wxSound * >(argp1);
16072 if (obj1) {
16073 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16074 if (!SWIG_IsOK(ecode2)) {
16075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16076 }
16077 arg2 = static_cast< unsigned int >(val2);
16078 }
16079 {
16080 if (!wxPyCheckForApp()) SWIG_fail;
16081 PyThreadState* __tstate = wxPyBeginAllowThreads();
16082 result = (bool)((wxSound const *)arg1)->Play(arg2);
16083 wxPyEndAllowThreads(__tstate);
16084 if (PyErr_Occurred()) SWIG_fail;
16085 }
16086 {
16087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16088 }
16089 return resultobj;
16090 fail:
16091 return NULL;
16092 }
16093
16094
16095 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16096 PyObject *resultobj = 0;
16097 wxString *arg1 = 0 ;
16098 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16099 bool result;
16100 bool temp1 = false ;
16101 unsigned int val2 ;
16102 int ecode2 = 0 ;
16103 PyObject * obj0 = 0 ;
16104 PyObject * obj1 = 0 ;
16105 char * kwnames[] = {
16106 (char *) "filename",(char *) "flags", NULL
16107 };
16108
16109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16110 {
16111 arg1 = wxString_in_helper(obj0);
16112 if (arg1 == NULL) SWIG_fail;
16113 temp1 = true;
16114 }
16115 if (obj1) {
16116 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16117 if (!SWIG_IsOK(ecode2)) {
16118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16119 }
16120 arg2 = static_cast< unsigned int >(val2);
16121 }
16122 {
16123 if (!wxPyCheckForApp()) SWIG_fail;
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16126 wxPyEndAllowThreads(__tstate);
16127 if (PyErr_Occurred()) SWIG_fail;
16128 }
16129 {
16130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16131 }
16132 {
16133 if (temp1)
16134 delete arg1;
16135 }
16136 return resultobj;
16137 fail:
16138 {
16139 if (temp1)
16140 delete arg1;
16141 }
16142 return NULL;
16143 }
16144
16145
16146 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16147 PyObject *resultobj = 0;
16148
16149 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16150 {
16151 if (!wxPyCheckForApp()) SWIG_fail;
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 wxSound::Stop();
16154 wxPyEndAllowThreads(__tstate);
16155 if (PyErr_Occurred()) SWIG_fail;
16156 }
16157 resultobj = SWIG_Py_Void();
16158 return resultobj;
16159 fail:
16160 return NULL;
16161 }
16162
16163
16164 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16165 PyObject *obj;
16166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16167 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16168 return SWIG_Py_Void();
16169 }
16170
16171 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16172 return SWIG_Python_InitShadowInstance(args);
16173 }
16174
16175 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16176 PyObject *resultobj = 0;
16177 wxString *arg1 = 0 ;
16178 wxString *arg2 = 0 ;
16179 wxString *arg3 = 0 ;
16180 wxString *arg4 = 0 ;
16181 wxFileTypeInfo *result = 0 ;
16182 bool temp1 = false ;
16183 bool temp2 = false ;
16184 bool temp3 = false ;
16185 bool temp4 = false ;
16186 PyObject * obj0 = 0 ;
16187 PyObject * obj1 = 0 ;
16188 PyObject * obj2 = 0 ;
16189 PyObject * obj3 = 0 ;
16190 char * kwnames[] = {
16191 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16192 };
16193
16194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16195 {
16196 arg1 = wxString_in_helper(obj0);
16197 if (arg1 == NULL) SWIG_fail;
16198 temp1 = true;
16199 }
16200 {
16201 arg2 = wxString_in_helper(obj1);
16202 if (arg2 == NULL) SWIG_fail;
16203 temp2 = true;
16204 }
16205 {
16206 arg3 = wxString_in_helper(obj2);
16207 if (arg3 == NULL) SWIG_fail;
16208 temp3 = true;
16209 }
16210 {
16211 arg4 = wxString_in_helper(obj3);
16212 if (arg4 == NULL) SWIG_fail;
16213 temp4 = true;
16214 }
16215 {
16216 PyThreadState* __tstate = wxPyBeginAllowThreads();
16217 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16218 wxPyEndAllowThreads(__tstate);
16219 if (PyErr_Occurred()) SWIG_fail;
16220 }
16221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16222 {
16223 if (temp1)
16224 delete arg1;
16225 }
16226 {
16227 if (temp2)
16228 delete arg2;
16229 }
16230 {
16231 if (temp3)
16232 delete arg3;
16233 }
16234 {
16235 if (temp4)
16236 delete arg4;
16237 }
16238 return resultobj;
16239 fail:
16240 {
16241 if (temp1)
16242 delete arg1;
16243 }
16244 {
16245 if (temp2)
16246 delete arg2;
16247 }
16248 {
16249 if (temp3)
16250 delete arg3;
16251 }
16252 {
16253 if (temp4)
16254 delete arg4;
16255 }
16256 return NULL;
16257 }
16258
16259
16260 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16261 PyObject *resultobj = 0;
16262 wxArrayString *arg1 = 0 ;
16263 wxFileTypeInfo *result = 0 ;
16264 bool temp1 = false ;
16265 PyObject * obj0 = 0 ;
16266 char * kwnames[] = {
16267 (char *) "sArray", NULL
16268 };
16269
16270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16271 {
16272 if (! PySequence_Check(obj0)) {
16273 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16274 SWIG_fail;
16275 }
16276 arg1 = new wxArrayString;
16277 temp1 = true;
16278 int i, len=PySequence_Length(obj0);
16279 for (i=0; i<len; i++) {
16280 PyObject* item = PySequence_GetItem(obj0, i);
16281 wxString* s = wxString_in_helper(item);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 arg1->Add(*s);
16284 delete s;
16285 Py_DECREF(item);
16286 }
16287 }
16288 {
16289 PyThreadState* __tstate = wxPyBeginAllowThreads();
16290 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16291 wxPyEndAllowThreads(__tstate);
16292 if (PyErr_Occurred()) SWIG_fail;
16293 }
16294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16295 {
16296 if (temp1) delete arg1;
16297 }
16298 return resultobj;
16299 fail:
16300 {
16301 if (temp1) delete arg1;
16302 }
16303 return NULL;
16304 }
16305
16306
16307 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16308 PyObject *resultobj = 0;
16309 wxFileTypeInfo *result = 0 ;
16310
16311 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16312 {
16313 PyThreadState* __tstate = wxPyBeginAllowThreads();
16314 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16326 PyObject *resultobj = 0;
16327 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16328 bool result;
16329 void *argp1 = 0 ;
16330 int res1 = 0 ;
16331 PyObject *swig_obj[1] ;
16332
16333 if (!args) SWIG_fail;
16334 swig_obj[0] = args;
16335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16336 if (!SWIG_IsOK(res1)) {
16337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16338 }
16339 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16340 {
16341 PyThreadState* __tstate = wxPyBeginAllowThreads();
16342 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16343 wxPyEndAllowThreads(__tstate);
16344 if (PyErr_Occurred()) SWIG_fail;
16345 }
16346 {
16347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16348 }
16349 return resultobj;
16350 fail:
16351 return NULL;
16352 }
16353
16354
16355 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16356 PyObject *resultobj = 0;
16357 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16358 wxString *arg2 = 0 ;
16359 int arg3 = (int) 0 ;
16360 void *argp1 = 0 ;
16361 int res1 = 0 ;
16362 bool temp2 = false ;
16363 int val3 ;
16364 int ecode3 = 0 ;
16365 PyObject * obj0 = 0 ;
16366 PyObject * obj1 = 0 ;
16367 PyObject * obj2 = 0 ;
16368 char * kwnames[] = {
16369 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16370 };
16371
16372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16374 if (!SWIG_IsOK(res1)) {
16375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16376 }
16377 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16378 {
16379 arg2 = wxString_in_helper(obj1);
16380 if (arg2 == NULL) SWIG_fail;
16381 temp2 = true;
16382 }
16383 if (obj2) {
16384 ecode3 = SWIG_AsVal_int(obj2, &val3);
16385 if (!SWIG_IsOK(ecode3)) {
16386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16387 }
16388 arg3 = static_cast< int >(val3);
16389 }
16390 {
16391 PyThreadState* __tstate = wxPyBeginAllowThreads();
16392 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16393 wxPyEndAllowThreads(__tstate);
16394 if (PyErr_Occurred()) SWIG_fail;
16395 }
16396 resultobj = SWIG_Py_Void();
16397 {
16398 if (temp2)
16399 delete arg2;
16400 }
16401 return resultobj;
16402 fail:
16403 {
16404 if (temp2)
16405 delete arg2;
16406 }
16407 return NULL;
16408 }
16409
16410
16411 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16412 PyObject *resultobj = 0;
16413 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16414 wxString *arg2 = 0 ;
16415 void *argp1 = 0 ;
16416 int res1 = 0 ;
16417 bool temp2 = false ;
16418 PyObject * obj0 = 0 ;
16419 PyObject * obj1 = 0 ;
16420 char * kwnames[] = {
16421 (char *) "self",(char *) "shortDesc", NULL
16422 };
16423
16424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16426 if (!SWIG_IsOK(res1)) {
16427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16428 }
16429 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16430 {
16431 arg2 = wxString_in_helper(obj1);
16432 if (arg2 == NULL) SWIG_fail;
16433 temp2 = true;
16434 }
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 (arg1)->SetShortDesc((wxString const &)*arg2);
16438 wxPyEndAllowThreads(__tstate);
16439 if (PyErr_Occurred()) SWIG_fail;
16440 }
16441 resultobj = SWIG_Py_Void();
16442 {
16443 if (temp2)
16444 delete arg2;
16445 }
16446 return resultobj;
16447 fail:
16448 {
16449 if (temp2)
16450 delete arg2;
16451 }
16452 return NULL;
16453 }
16454
16455
16456 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16457 PyObject *resultobj = 0;
16458 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16459 wxString *result = 0 ;
16460 void *argp1 = 0 ;
16461 int res1 = 0 ;
16462 PyObject *swig_obj[1] ;
16463
16464 if (!args) SWIG_fail;
16465 swig_obj[0] = args;
16466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16467 if (!SWIG_IsOK(res1)) {
16468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16469 }
16470 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16471 {
16472 PyThreadState* __tstate = wxPyBeginAllowThreads();
16473 {
16474 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16475 result = (wxString *) &_result_ref;
16476 }
16477 wxPyEndAllowThreads(__tstate);
16478 if (PyErr_Occurred()) SWIG_fail;
16479 }
16480 {
16481 #if wxUSE_UNICODE
16482 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16483 #else
16484 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16485 #endif
16486 }
16487 return resultobj;
16488 fail:
16489 return NULL;
16490 }
16491
16492
16493 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16494 PyObject *resultobj = 0;
16495 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16496 wxString *result = 0 ;
16497 void *argp1 = 0 ;
16498 int res1 = 0 ;
16499 PyObject *swig_obj[1] ;
16500
16501 if (!args) SWIG_fail;
16502 swig_obj[0] = args;
16503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16504 if (!SWIG_IsOK(res1)) {
16505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16506 }
16507 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16508 {
16509 PyThreadState* __tstate = wxPyBeginAllowThreads();
16510 {
16511 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16512 result = (wxString *) &_result_ref;
16513 }
16514 wxPyEndAllowThreads(__tstate);
16515 if (PyErr_Occurred()) SWIG_fail;
16516 }
16517 {
16518 #if wxUSE_UNICODE
16519 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16520 #else
16521 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16522 #endif
16523 }
16524 return resultobj;
16525 fail:
16526 return NULL;
16527 }
16528
16529
16530 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16531 PyObject *resultobj = 0;
16532 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16533 wxString *result = 0 ;
16534 void *argp1 = 0 ;
16535 int res1 = 0 ;
16536 PyObject *swig_obj[1] ;
16537
16538 if (!args) SWIG_fail;
16539 swig_obj[0] = args;
16540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16541 if (!SWIG_IsOK(res1)) {
16542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16543 }
16544 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 {
16548 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16549 result = (wxString *) &_result_ref;
16550 }
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 {
16555 #if wxUSE_UNICODE
16556 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16557 #else
16558 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16559 #endif
16560 }
16561 return resultobj;
16562 fail:
16563 return NULL;
16564 }
16565
16566
16567 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16568 PyObject *resultobj = 0;
16569 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16570 wxString *result = 0 ;
16571 void *argp1 = 0 ;
16572 int res1 = 0 ;
16573 PyObject *swig_obj[1] ;
16574
16575 if (!args) SWIG_fail;
16576 swig_obj[0] = args;
16577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16578 if (!SWIG_IsOK(res1)) {
16579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16580 }
16581 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 {
16585 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16586 result = (wxString *) &_result_ref;
16587 }
16588 wxPyEndAllowThreads(__tstate);
16589 if (PyErr_Occurred()) SWIG_fail;
16590 }
16591 {
16592 #if wxUSE_UNICODE
16593 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16594 #else
16595 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16596 #endif
16597 }
16598 return resultobj;
16599 fail:
16600 return NULL;
16601 }
16602
16603
16604 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16605 PyObject *resultobj = 0;
16606 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16607 wxString *result = 0 ;
16608 void *argp1 = 0 ;
16609 int res1 = 0 ;
16610 PyObject *swig_obj[1] ;
16611
16612 if (!args) SWIG_fail;
16613 swig_obj[0] = args;
16614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16615 if (!SWIG_IsOK(res1)) {
16616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16617 }
16618 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16619 {
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 {
16622 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16623 result = (wxString *) &_result_ref;
16624 }
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 {
16629 #if wxUSE_UNICODE
16630 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16631 #else
16632 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16633 #endif
16634 }
16635 return resultobj;
16636 fail:
16637 return NULL;
16638 }
16639
16640
16641 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16642 PyObject *resultobj = 0;
16643 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16644 wxArrayString *result = 0 ;
16645 void *argp1 = 0 ;
16646 int res1 = 0 ;
16647 PyObject *swig_obj[1] ;
16648
16649 if (!args) SWIG_fail;
16650 swig_obj[0] = args;
16651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16652 if (!SWIG_IsOK(res1)) {
16653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16654 }
16655 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16656 {
16657 PyThreadState* __tstate = wxPyBeginAllowThreads();
16658 {
16659 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16660 result = (wxArrayString *) &_result_ref;
16661 }
16662 wxPyEndAllowThreads(__tstate);
16663 if (PyErr_Occurred()) SWIG_fail;
16664 }
16665 {
16666 resultobj = wxArrayString2PyList_helper(*result);
16667 }
16668 return resultobj;
16669 fail:
16670 return NULL;
16671 }
16672
16673
16674 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16675 PyObject *resultobj = 0;
16676 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16677 size_t result;
16678 void *argp1 = 0 ;
16679 int res1 = 0 ;
16680 PyObject *swig_obj[1] ;
16681
16682 if (!args) SWIG_fail;
16683 swig_obj[0] = args;
16684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16685 if (!SWIG_IsOK(res1)) {
16686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16687 }
16688 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16689 {
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16692 wxPyEndAllowThreads(__tstate);
16693 if (PyErr_Occurred()) SWIG_fail;
16694 }
16695 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16696 return resultobj;
16697 fail:
16698 return NULL;
16699 }
16700
16701
16702 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16703 PyObject *resultobj = 0;
16704 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16705 wxString *result = 0 ;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 PyObject *swig_obj[1] ;
16709
16710 if (!args) SWIG_fail;
16711 swig_obj[0] = args;
16712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16713 if (!SWIG_IsOK(res1)) {
16714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16715 }
16716 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 {
16720 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16721 result = (wxString *) &_result_ref;
16722 }
16723 wxPyEndAllowThreads(__tstate);
16724 if (PyErr_Occurred()) SWIG_fail;
16725 }
16726 {
16727 #if wxUSE_UNICODE
16728 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16729 #else
16730 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16731 #endif
16732 }
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16740 PyObject *resultobj = 0;
16741 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16742 int result;
16743 void *argp1 = 0 ;
16744 int res1 = 0 ;
16745 PyObject *swig_obj[1] ;
16746
16747 if (!args) SWIG_fail;
16748 swig_obj[0] = args;
16749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16750 if (!SWIG_IsOK(res1)) {
16751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16752 }
16753 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16754 {
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16757 wxPyEndAllowThreads(__tstate);
16758 if (PyErr_Occurred()) SWIG_fail;
16759 }
16760 resultobj = SWIG_From_int(static_cast< int >(result));
16761 return resultobj;
16762 fail:
16763 return NULL;
16764 }
16765
16766
16767 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16768 PyObject *obj;
16769 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16770 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16771 return SWIG_Py_Void();
16772 }
16773
16774 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16775 return SWIG_Python_InitShadowInstance(args);
16776 }
16777
16778 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16779 PyObject *resultobj = 0;
16780 wxFileTypeInfo *arg1 = 0 ;
16781 wxFileType *result = 0 ;
16782 void *argp1 = 0 ;
16783 int res1 = 0 ;
16784 PyObject * obj0 = 0 ;
16785 char * kwnames[] = {
16786 (char *) "ftInfo", NULL
16787 };
16788
16789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16790 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16791 if (!SWIG_IsOK(res1)) {
16792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16793 }
16794 if (!argp1) {
16795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16796 }
16797 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16798 {
16799 PyThreadState* __tstate = wxPyBeginAllowThreads();
16800 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16801 wxPyEndAllowThreads(__tstate);
16802 if (PyErr_Occurred()) SWIG_fail;
16803 }
16804 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16805 return resultobj;
16806 fail:
16807 return NULL;
16808 }
16809
16810
16811 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16812 PyObject *resultobj = 0;
16813 wxFileType *arg1 = (wxFileType *) 0 ;
16814 void *argp1 = 0 ;
16815 int res1 = 0 ;
16816 PyObject *swig_obj[1] ;
16817
16818 if (!args) SWIG_fail;
16819 swig_obj[0] = args;
16820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16821 if (!SWIG_IsOK(res1)) {
16822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16823 }
16824 arg1 = reinterpret_cast< wxFileType * >(argp1);
16825 {
16826 PyThreadState* __tstate = wxPyBeginAllowThreads();
16827 delete arg1;
16828
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 resultobj = SWIG_Py_Void();
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16840 PyObject *resultobj = 0;
16841 wxFileType *arg1 = (wxFileType *) 0 ;
16842 PyObject *result = 0 ;
16843 void *argp1 = 0 ;
16844 int res1 = 0 ;
16845 PyObject *swig_obj[1] ;
16846
16847 if (!args) SWIG_fail;
16848 swig_obj[0] = args;
16849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16850 if (!SWIG_IsOK(res1)) {
16851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16852 }
16853 arg1 = reinterpret_cast< wxFileType * >(argp1);
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = (PyObject *)wxFileType_GetMimeType(arg1);
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 resultobj = result;
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16868 PyObject *resultobj = 0;
16869 wxFileType *arg1 = (wxFileType *) 0 ;
16870 PyObject *result = 0 ;
16871 void *argp1 = 0 ;
16872 int res1 = 0 ;
16873 PyObject *swig_obj[1] ;
16874
16875 if (!args) SWIG_fail;
16876 swig_obj[0] = args;
16877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16878 if (!SWIG_IsOK(res1)) {
16879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16880 }
16881 arg1 = reinterpret_cast< wxFileType * >(argp1);
16882 {
16883 PyThreadState* __tstate = wxPyBeginAllowThreads();
16884 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16885 wxPyEndAllowThreads(__tstate);
16886 if (PyErr_Occurred()) SWIG_fail;
16887 }
16888 resultobj = result;
16889 return resultobj;
16890 fail:
16891 return NULL;
16892 }
16893
16894
16895 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16896 PyObject *resultobj = 0;
16897 wxFileType *arg1 = (wxFileType *) 0 ;
16898 PyObject *result = 0 ;
16899 void *argp1 = 0 ;
16900 int res1 = 0 ;
16901 PyObject *swig_obj[1] ;
16902
16903 if (!args) SWIG_fail;
16904 swig_obj[0] = args;
16905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16906 if (!SWIG_IsOK(res1)) {
16907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16908 }
16909 arg1 = reinterpret_cast< wxFileType * >(argp1);
16910 {
16911 PyThreadState* __tstate = wxPyBeginAllowThreads();
16912 result = (PyObject *)wxFileType_GetExtensions(arg1);
16913 wxPyEndAllowThreads(__tstate);
16914 if (PyErr_Occurred()) SWIG_fail;
16915 }
16916 resultobj = result;
16917 return resultobj;
16918 fail:
16919 return NULL;
16920 }
16921
16922
16923 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16924 PyObject *resultobj = 0;
16925 wxFileType *arg1 = (wxFileType *) 0 ;
16926 wxIcon *result = 0 ;
16927 void *argp1 = 0 ;
16928 int res1 = 0 ;
16929 PyObject *swig_obj[1] ;
16930
16931 if (!args) SWIG_fail;
16932 swig_obj[0] = args;
16933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16934 if (!SWIG_IsOK(res1)) {
16935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16936 }
16937 arg1 = reinterpret_cast< wxFileType * >(argp1);
16938 {
16939 PyThreadState* __tstate = wxPyBeginAllowThreads();
16940 result = (wxIcon *)wxFileType_GetIcon(arg1);
16941 wxPyEndAllowThreads(__tstate);
16942 if (PyErr_Occurred()) SWIG_fail;
16943 }
16944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16945 return resultobj;
16946 fail:
16947 return NULL;
16948 }
16949
16950
16951 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16952 PyObject *resultobj = 0;
16953 wxFileType *arg1 = (wxFileType *) 0 ;
16954 PyObject *result = 0 ;
16955 void *argp1 = 0 ;
16956 int res1 = 0 ;
16957 PyObject *swig_obj[1] ;
16958
16959 if (!args) SWIG_fail;
16960 swig_obj[0] = args;
16961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16962 if (!SWIG_IsOK(res1)) {
16963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16964 }
16965 arg1 = reinterpret_cast< wxFileType * >(argp1);
16966 {
16967 PyThreadState* __tstate = wxPyBeginAllowThreads();
16968 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16969 wxPyEndAllowThreads(__tstate);
16970 if (PyErr_Occurred()) SWIG_fail;
16971 }
16972 resultobj = result;
16973 return resultobj;
16974 fail:
16975 return NULL;
16976 }
16977
16978
16979 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16980 PyObject *resultobj = 0;
16981 wxFileType *arg1 = (wxFileType *) 0 ;
16982 PyObject *result = 0 ;
16983 void *argp1 = 0 ;
16984 int res1 = 0 ;
16985 PyObject *swig_obj[1] ;
16986
16987 if (!args) SWIG_fail;
16988 swig_obj[0] = args;
16989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16990 if (!SWIG_IsOK(res1)) {
16991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16992 }
16993 arg1 = reinterpret_cast< wxFileType * >(argp1);
16994 {
16995 PyThreadState* __tstate = wxPyBeginAllowThreads();
16996 result = (PyObject *)wxFileType_GetDescription(arg1);
16997 wxPyEndAllowThreads(__tstate);
16998 if (PyErr_Occurred()) SWIG_fail;
16999 }
17000 resultobj = result;
17001 return resultobj;
17002 fail:
17003 return NULL;
17004 }
17005
17006
17007 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj = 0;
17009 wxFileType *arg1 = (wxFileType *) 0 ;
17010 wxString *arg2 = 0 ;
17011 wxString const &arg3_defvalue = wxPyEmptyString ;
17012 wxString *arg3 = (wxString *) &arg3_defvalue ;
17013 PyObject *result = 0 ;
17014 void *argp1 = 0 ;
17015 int res1 = 0 ;
17016 bool temp2 = false ;
17017 bool temp3 = false ;
17018 PyObject * obj0 = 0 ;
17019 PyObject * obj1 = 0 ;
17020 PyObject * obj2 = 0 ;
17021 char * kwnames[] = {
17022 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17023 };
17024
17025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17027 if (!SWIG_IsOK(res1)) {
17028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17029 }
17030 arg1 = reinterpret_cast< wxFileType * >(argp1);
17031 {
17032 arg2 = wxString_in_helper(obj1);
17033 if (arg2 == NULL) SWIG_fail;
17034 temp2 = true;
17035 }
17036 if (obj2) {
17037 {
17038 arg3 = wxString_in_helper(obj2);
17039 if (arg3 == NULL) SWIG_fail;
17040 temp3 = true;
17041 }
17042 }
17043 {
17044 PyThreadState* __tstate = wxPyBeginAllowThreads();
17045 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17046 wxPyEndAllowThreads(__tstate);
17047 if (PyErr_Occurred()) SWIG_fail;
17048 }
17049 resultobj = result;
17050 {
17051 if (temp2)
17052 delete arg2;
17053 }
17054 {
17055 if (temp3)
17056 delete arg3;
17057 }
17058 return resultobj;
17059 fail:
17060 {
17061 if (temp2)
17062 delete arg2;
17063 }
17064 {
17065 if (temp3)
17066 delete arg3;
17067 }
17068 return NULL;
17069 }
17070
17071
17072 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17073 PyObject *resultobj = 0;
17074 wxFileType *arg1 = (wxFileType *) 0 ;
17075 wxString *arg2 = 0 ;
17076 wxString const &arg3_defvalue = wxPyEmptyString ;
17077 wxString *arg3 = (wxString *) &arg3_defvalue ;
17078 PyObject *result = 0 ;
17079 void *argp1 = 0 ;
17080 int res1 = 0 ;
17081 bool temp2 = false ;
17082 bool temp3 = false ;
17083 PyObject * obj0 = 0 ;
17084 PyObject * obj1 = 0 ;
17085 PyObject * obj2 = 0 ;
17086 char * kwnames[] = {
17087 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17088 };
17089
17090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17092 if (!SWIG_IsOK(res1)) {
17093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17094 }
17095 arg1 = reinterpret_cast< wxFileType * >(argp1);
17096 {
17097 arg2 = wxString_in_helper(obj1);
17098 if (arg2 == NULL) SWIG_fail;
17099 temp2 = true;
17100 }
17101 if (obj2) {
17102 {
17103 arg3 = wxString_in_helper(obj2);
17104 if (arg3 == NULL) SWIG_fail;
17105 temp3 = true;
17106 }
17107 }
17108 {
17109 PyThreadState* __tstate = wxPyBeginAllowThreads();
17110 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17111 wxPyEndAllowThreads(__tstate);
17112 if (PyErr_Occurred()) SWIG_fail;
17113 }
17114 resultobj = result;
17115 {
17116 if (temp2)
17117 delete arg2;
17118 }
17119 {
17120 if (temp3)
17121 delete arg3;
17122 }
17123 return resultobj;
17124 fail:
17125 {
17126 if (temp2)
17127 delete arg2;
17128 }
17129 {
17130 if (temp3)
17131 delete arg3;
17132 }
17133 return NULL;
17134 }
17135
17136
17137 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj = 0;
17139 wxFileType *arg1 = (wxFileType *) 0 ;
17140 wxString *arg2 = 0 ;
17141 wxString const &arg3_defvalue = wxPyEmptyString ;
17142 wxString *arg3 = (wxString *) &arg3_defvalue ;
17143 PyObject *result = 0 ;
17144 void *argp1 = 0 ;
17145 int res1 = 0 ;
17146 bool temp2 = false ;
17147 bool temp3 = false ;
17148 PyObject * obj0 = 0 ;
17149 PyObject * obj1 = 0 ;
17150 PyObject * obj2 = 0 ;
17151 char * kwnames[] = {
17152 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17153 };
17154
17155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17157 if (!SWIG_IsOK(res1)) {
17158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17159 }
17160 arg1 = reinterpret_cast< wxFileType * >(argp1);
17161 {
17162 arg2 = wxString_in_helper(obj1);
17163 if (arg2 == NULL) SWIG_fail;
17164 temp2 = true;
17165 }
17166 if (obj2) {
17167 {
17168 arg3 = wxString_in_helper(obj2);
17169 if (arg3 == NULL) SWIG_fail;
17170 temp3 = true;
17171 }
17172 }
17173 {
17174 PyThreadState* __tstate = wxPyBeginAllowThreads();
17175 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 resultobj = result;
17180 {
17181 if (temp2)
17182 delete arg2;
17183 }
17184 {
17185 if (temp3)
17186 delete arg3;
17187 }
17188 return resultobj;
17189 fail:
17190 {
17191 if (temp2)
17192 delete arg2;
17193 }
17194 {
17195 if (temp3)
17196 delete arg3;
17197 }
17198 return NULL;
17199 }
17200
17201
17202 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17203 PyObject *resultobj = 0;
17204 wxFileType *arg1 = (wxFileType *) 0 ;
17205 wxString *arg2 = 0 ;
17206 wxString *arg3 = 0 ;
17207 bool arg4 = (bool) true ;
17208 bool result;
17209 void *argp1 = 0 ;
17210 int res1 = 0 ;
17211 bool temp2 = false ;
17212 bool temp3 = false ;
17213 bool val4 ;
17214 int ecode4 = 0 ;
17215 PyObject * obj0 = 0 ;
17216 PyObject * obj1 = 0 ;
17217 PyObject * obj2 = 0 ;
17218 PyObject * obj3 = 0 ;
17219 char * kwnames[] = {
17220 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17221 };
17222
17223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17225 if (!SWIG_IsOK(res1)) {
17226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17227 }
17228 arg1 = reinterpret_cast< wxFileType * >(argp1);
17229 {
17230 arg2 = wxString_in_helper(obj1);
17231 if (arg2 == NULL) SWIG_fail;
17232 temp2 = true;
17233 }
17234 {
17235 arg3 = wxString_in_helper(obj2);
17236 if (arg3 == NULL) SWIG_fail;
17237 temp3 = true;
17238 }
17239 if (obj3) {
17240 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17241 if (!SWIG_IsOK(ecode4)) {
17242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17243 }
17244 arg4 = static_cast< bool >(val4);
17245 }
17246 {
17247 PyThreadState* __tstate = wxPyBeginAllowThreads();
17248 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 {
17253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17254 }
17255 {
17256 if (temp2)
17257 delete arg2;
17258 }
17259 {
17260 if (temp3)
17261 delete arg3;
17262 }
17263 return resultobj;
17264 fail:
17265 {
17266 if (temp2)
17267 delete arg2;
17268 }
17269 {
17270 if (temp3)
17271 delete arg3;
17272 }
17273 return NULL;
17274 }
17275
17276
17277 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17278 PyObject *resultobj = 0;
17279 wxFileType *arg1 = (wxFileType *) 0 ;
17280 wxString const &arg2_defvalue = wxPyEmptyString ;
17281 wxString *arg2 = (wxString *) &arg2_defvalue ;
17282 int arg3 = (int) 0 ;
17283 bool result;
17284 void *argp1 = 0 ;
17285 int res1 = 0 ;
17286 bool temp2 = false ;
17287 int val3 ;
17288 int ecode3 = 0 ;
17289 PyObject * obj0 = 0 ;
17290 PyObject * obj1 = 0 ;
17291 PyObject * obj2 = 0 ;
17292 char * kwnames[] = {
17293 (char *) "self",(char *) "cmd",(char *) "index", NULL
17294 };
17295
17296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17298 if (!SWIG_IsOK(res1)) {
17299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17300 }
17301 arg1 = reinterpret_cast< wxFileType * >(argp1);
17302 if (obj1) {
17303 {
17304 arg2 = wxString_in_helper(obj1);
17305 if (arg2 == NULL) SWIG_fail;
17306 temp2 = true;
17307 }
17308 }
17309 if (obj2) {
17310 ecode3 = SWIG_AsVal_int(obj2, &val3);
17311 if (!SWIG_IsOK(ecode3)) {
17312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17313 }
17314 arg3 = static_cast< int >(val3);
17315 }
17316 {
17317 PyThreadState* __tstate = wxPyBeginAllowThreads();
17318 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17319 wxPyEndAllowThreads(__tstate);
17320 if (PyErr_Occurred()) SWIG_fail;
17321 }
17322 {
17323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17324 }
17325 {
17326 if (temp2)
17327 delete arg2;
17328 }
17329 return resultobj;
17330 fail:
17331 {
17332 if (temp2)
17333 delete arg2;
17334 }
17335 return NULL;
17336 }
17337
17338
17339 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17340 PyObject *resultobj = 0;
17341 wxFileType *arg1 = (wxFileType *) 0 ;
17342 bool result;
17343 void *argp1 = 0 ;
17344 int res1 = 0 ;
17345 PyObject *swig_obj[1] ;
17346
17347 if (!args) SWIG_fail;
17348 swig_obj[0] = args;
17349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17350 if (!SWIG_IsOK(res1)) {
17351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17352 }
17353 arg1 = reinterpret_cast< wxFileType * >(argp1);
17354 {
17355 PyThreadState* __tstate = wxPyBeginAllowThreads();
17356 result = (bool)(arg1)->Unassociate();
17357 wxPyEndAllowThreads(__tstate);
17358 if (PyErr_Occurred()) SWIG_fail;
17359 }
17360 {
17361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17362 }
17363 return resultobj;
17364 fail:
17365 return NULL;
17366 }
17367
17368
17369 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17370 PyObject *resultobj = 0;
17371 wxString *arg1 = 0 ;
17372 wxString *arg2 = 0 ;
17373 wxString const &arg3_defvalue = wxPyEmptyString ;
17374 wxString *arg3 = (wxString *) &arg3_defvalue ;
17375 wxString result;
17376 bool temp1 = false ;
17377 bool temp2 = false ;
17378 bool temp3 = false ;
17379 PyObject * obj0 = 0 ;
17380 PyObject * obj1 = 0 ;
17381 PyObject * obj2 = 0 ;
17382 char * kwnames[] = {
17383 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17384 };
17385
17386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17387 {
17388 arg1 = wxString_in_helper(obj0);
17389 if (arg1 == NULL) SWIG_fail;
17390 temp1 = true;
17391 }
17392 {
17393 arg2 = wxString_in_helper(obj1);
17394 if (arg2 == NULL) SWIG_fail;
17395 temp2 = true;
17396 }
17397 if (obj2) {
17398 {
17399 arg3 = wxString_in_helper(obj2);
17400 if (arg3 == NULL) SWIG_fail;
17401 temp3 = true;
17402 }
17403 }
17404 {
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 #if wxUSE_UNICODE
17412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17413 #else
17414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17415 #endif
17416 }
17417 {
17418 if (temp1)
17419 delete arg1;
17420 }
17421 {
17422 if (temp2)
17423 delete arg2;
17424 }
17425 {
17426 if (temp3)
17427 delete arg3;
17428 }
17429 return resultobj;
17430 fail:
17431 {
17432 if (temp1)
17433 delete arg1;
17434 }
17435 {
17436 if (temp2)
17437 delete arg2;
17438 }
17439 {
17440 if (temp3)
17441 delete arg3;
17442 }
17443 return NULL;
17444 }
17445
17446
17447 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17448 PyObject *obj;
17449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17450 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17451 return SWIG_Py_Void();
17452 }
17453
17454 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17455 return SWIG_Python_InitShadowInstance(args);
17456 }
17457
17458 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17459 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17460 return 1;
17461 }
17462
17463
17464 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17465 PyObject *pyobj = 0;
17466
17467 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17468 return pyobj;
17469 }
17470
17471
17472 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj = 0;
17474 wxString *arg1 = 0 ;
17475 wxString *arg2 = 0 ;
17476 bool result;
17477 bool temp1 = false ;
17478 bool temp2 = false ;
17479 PyObject * obj0 = 0 ;
17480 PyObject * obj1 = 0 ;
17481 char * kwnames[] = {
17482 (char *) "mimeType",(char *) "wildcard", NULL
17483 };
17484
17485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17486 {
17487 arg1 = wxString_in_helper(obj0);
17488 if (arg1 == NULL) SWIG_fail;
17489 temp1 = true;
17490 }
17491 {
17492 arg2 = wxString_in_helper(obj1);
17493 if (arg2 == NULL) SWIG_fail;
17494 temp2 = true;
17495 }
17496 {
17497 PyThreadState* __tstate = wxPyBeginAllowThreads();
17498 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17499 wxPyEndAllowThreads(__tstate);
17500 if (PyErr_Occurred()) SWIG_fail;
17501 }
17502 {
17503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17504 }
17505 {
17506 if (temp1)
17507 delete arg1;
17508 }
17509 {
17510 if (temp2)
17511 delete arg2;
17512 }
17513 return resultobj;
17514 fail:
17515 {
17516 if (temp1)
17517 delete arg1;
17518 }
17519 {
17520 if (temp2)
17521 delete arg2;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17528 PyObject *resultobj = 0;
17529 wxMimeTypesManager *result = 0 ;
17530
17531 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17535 wxPyEndAllowThreads(__tstate);
17536 if (PyErr_Occurred()) SWIG_fail;
17537 }
17538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17539 return resultobj;
17540 fail:
17541 return NULL;
17542 }
17543
17544
17545 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17546 PyObject *resultobj = 0;
17547 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17548 int arg2 = (int) wxMAILCAP_ALL ;
17549 wxString const &arg3_defvalue = wxPyEmptyString ;
17550 wxString *arg3 = (wxString *) &arg3_defvalue ;
17551 void *argp1 = 0 ;
17552 int res1 = 0 ;
17553 int val2 ;
17554 int ecode2 = 0 ;
17555 bool temp3 = false ;
17556 PyObject * obj0 = 0 ;
17557 PyObject * obj1 = 0 ;
17558 PyObject * obj2 = 0 ;
17559 char * kwnames[] = {
17560 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17561 };
17562
17563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17565 if (!SWIG_IsOK(res1)) {
17566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17567 }
17568 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17569 if (obj1) {
17570 ecode2 = SWIG_AsVal_int(obj1, &val2);
17571 if (!SWIG_IsOK(ecode2)) {
17572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17573 }
17574 arg2 = static_cast< int >(val2);
17575 }
17576 if (obj2) {
17577 {
17578 arg3 = wxString_in_helper(obj2);
17579 if (arg3 == NULL) SWIG_fail;
17580 temp3 = true;
17581 }
17582 }
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17586 wxPyEndAllowThreads(__tstate);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 }
17589 resultobj = SWIG_Py_Void();
17590 {
17591 if (temp3)
17592 delete arg3;
17593 }
17594 return resultobj;
17595 fail:
17596 {
17597 if (temp3)
17598 delete arg3;
17599 }
17600 return NULL;
17601 }
17602
17603
17604 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17605 PyObject *resultobj = 0;
17606 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17607 void *argp1 = 0 ;
17608 int res1 = 0 ;
17609 PyObject *swig_obj[1] ;
17610
17611 if (!args) SWIG_fail;
17612 swig_obj[0] = args;
17613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17614 if (!SWIG_IsOK(res1)) {
17615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17616 }
17617 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 (arg1)->ClearData();
17621 wxPyEndAllowThreads(__tstate);
17622 if (PyErr_Occurred()) SWIG_fail;
17623 }
17624 resultobj = SWIG_Py_Void();
17625 return resultobj;
17626 fail:
17627 return NULL;
17628 }
17629
17630
17631 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17632 PyObject *resultobj = 0;
17633 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17634 wxString *arg2 = 0 ;
17635 wxFileType *result = 0 ;
17636 void *argp1 = 0 ;
17637 int res1 = 0 ;
17638 bool temp2 = false ;
17639 PyObject * obj0 = 0 ;
17640 PyObject * obj1 = 0 ;
17641 char * kwnames[] = {
17642 (char *) "self",(char *) "ext", NULL
17643 };
17644
17645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17647 if (!SWIG_IsOK(res1)) {
17648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17649 }
17650 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17651 {
17652 arg2 = wxString_in_helper(obj1);
17653 if (arg2 == NULL) SWIG_fail;
17654 temp2 = true;
17655 }
17656 {
17657 PyThreadState* __tstate = wxPyBeginAllowThreads();
17658 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17659 wxPyEndAllowThreads(__tstate);
17660 if (PyErr_Occurred()) SWIG_fail;
17661 }
17662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17663 {
17664 if (temp2)
17665 delete arg2;
17666 }
17667 return resultobj;
17668 fail:
17669 {
17670 if (temp2)
17671 delete arg2;
17672 }
17673 return NULL;
17674 }
17675
17676
17677 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17678 PyObject *resultobj = 0;
17679 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17680 wxString *arg2 = 0 ;
17681 wxFileType *result = 0 ;
17682 void *argp1 = 0 ;
17683 int res1 = 0 ;
17684 bool temp2 = false ;
17685 PyObject * obj0 = 0 ;
17686 PyObject * obj1 = 0 ;
17687 char * kwnames[] = {
17688 (char *) "self",(char *) "mimeType", NULL
17689 };
17690
17691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17693 if (!SWIG_IsOK(res1)) {
17694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17695 }
17696 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17697 {
17698 arg2 = wxString_in_helper(obj1);
17699 if (arg2 == NULL) SWIG_fail;
17700 temp2 = true;
17701 }
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17709 {
17710 if (temp2)
17711 delete arg2;
17712 }
17713 return resultobj;
17714 fail:
17715 {
17716 if (temp2)
17717 delete arg2;
17718 }
17719 return NULL;
17720 }
17721
17722
17723 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj = 0;
17725 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17726 wxString *arg2 = 0 ;
17727 bool arg3 = (bool) false ;
17728 bool result;
17729 void *argp1 = 0 ;
17730 int res1 = 0 ;
17731 bool temp2 = false ;
17732 bool val3 ;
17733 int ecode3 = 0 ;
17734 PyObject * obj0 = 0 ;
17735 PyObject * obj1 = 0 ;
17736 PyObject * obj2 = 0 ;
17737 char * kwnames[] = {
17738 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17739 };
17740
17741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17743 if (!SWIG_IsOK(res1)) {
17744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17745 }
17746 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17747 {
17748 arg2 = wxString_in_helper(obj1);
17749 if (arg2 == NULL) SWIG_fail;
17750 temp2 = true;
17751 }
17752 if (obj2) {
17753 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17754 if (!SWIG_IsOK(ecode3)) {
17755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17756 }
17757 arg3 = static_cast< bool >(val3);
17758 }
17759 {
17760 PyThreadState* __tstate = wxPyBeginAllowThreads();
17761 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17762 wxPyEndAllowThreads(__tstate);
17763 if (PyErr_Occurred()) SWIG_fail;
17764 }
17765 {
17766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17767 }
17768 {
17769 if (temp2)
17770 delete arg2;
17771 }
17772 return resultobj;
17773 fail:
17774 {
17775 if (temp2)
17776 delete arg2;
17777 }
17778 return NULL;
17779 }
17780
17781
17782 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17783 PyObject *resultobj = 0;
17784 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17785 wxString *arg2 = 0 ;
17786 bool result;
17787 void *argp1 = 0 ;
17788 int res1 = 0 ;
17789 bool temp2 = false ;
17790 PyObject * obj0 = 0 ;
17791 PyObject * obj1 = 0 ;
17792 char * kwnames[] = {
17793 (char *) "self",(char *) "filename", NULL
17794 };
17795
17796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17798 if (!SWIG_IsOK(res1)) {
17799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17800 }
17801 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17802 {
17803 arg2 = wxString_in_helper(obj1);
17804 if (arg2 == NULL) SWIG_fail;
17805 temp2 = true;
17806 }
17807 {
17808 PyThreadState* __tstate = wxPyBeginAllowThreads();
17809 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17810 wxPyEndAllowThreads(__tstate);
17811 if (PyErr_Occurred()) SWIG_fail;
17812 }
17813 {
17814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17815 }
17816 {
17817 if (temp2)
17818 delete arg2;
17819 }
17820 return resultobj;
17821 fail:
17822 {
17823 if (temp2)
17824 delete arg2;
17825 }
17826 return NULL;
17827 }
17828
17829
17830 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17831 PyObject *resultobj = 0;
17832 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17833 PyObject *result = 0 ;
17834 void *argp1 = 0 ;
17835 int res1 = 0 ;
17836 PyObject *swig_obj[1] ;
17837
17838 if (!args) SWIG_fail;
17839 swig_obj[0] = args;
17840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17841 if (!SWIG_IsOK(res1)) {
17842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17843 }
17844 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17845 {
17846 PyThreadState* __tstate = wxPyBeginAllowThreads();
17847 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17848 wxPyEndAllowThreads(__tstate);
17849 if (PyErr_Occurred()) SWIG_fail;
17850 }
17851 resultobj = result;
17852 return resultobj;
17853 fail:
17854 return NULL;
17855 }
17856
17857
17858 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17859 PyObject *resultobj = 0;
17860 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17861 wxFileTypeInfo *arg2 = 0 ;
17862 void *argp1 = 0 ;
17863 int res1 = 0 ;
17864 void *argp2 = 0 ;
17865 int res2 = 0 ;
17866 PyObject * obj0 = 0 ;
17867 PyObject * obj1 = 0 ;
17868 char * kwnames[] = {
17869 (char *) "self",(char *) "ft", NULL
17870 };
17871
17872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17874 if (!SWIG_IsOK(res1)) {
17875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17876 }
17877 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17878 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17879 if (!SWIG_IsOK(res2)) {
17880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17881 }
17882 if (!argp2) {
17883 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17884 }
17885 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17886 {
17887 PyThreadState* __tstate = wxPyBeginAllowThreads();
17888 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 resultobj = SWIG_Py_Void();
17893 return resultobj;
17894 fail:
17895 return NULL;
17896 }
17897
17898
17899 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17900 PyObject *resultobj = 0;
17901 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17902 wxFileTypeInfo *arg2 = 0 ;
17903 wxFileType *result = 0 ;
17904 void *argp1 = 0 ;
17905 int res1 = 0 ;
17906 void *argp2 = 0 ;
17907 int res2 = 0 ;
17908 PyObject * obj0 = 0 ;
17909 PyObject * obj1 = 0 ;
17910 char * kwnames[] = {
17911 (char *) "self",(char *) "ftInfo", NULL
17912 };
17913
17914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17916 if (!SWIG_IsOK(res1)) {
17917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17918 }
17919 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17920 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17921 if (!SWIG_IsOK(res2)) {
17922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17923 }
17924 if (!argp2) {
17925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17926 }
17927 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17928 {
17929 PyThreadState* __tstate = wxPyBeginAllowThreads();
17930 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17931 wxPyEndAllowThreads(__tstate);
17932 if (PyErr_Occurred()) SWIG_fail;
17933 }
17934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17935 return resultobj;
17936 fail:
17937 return NULL;
17938 }
17939
17940
17941 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17942 PyObject *resultobj = 0;
17943 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17944 wxFileType *arg2 = (wxFileType *) 0 ;
17945 bool result;
17946 void *argp1 = 0 ;
17947 int res1 = 0 ;
17948 void *argp2 = 0 ;
17949 int res2 = 0 ;
17950 PyObject * obj0 = 0 ;
17951 PyObject * obj1 = 0 ;
17952 char * kwnames[] = {
17953 (char *) "self",(char *) "ft", NULL
17954 };
17955
17956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17958 if (!SWIG_IsOK(res1)) {
17959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17960 }
17961 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17962 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17963 if (!SWIG_IsOK(res2)) {
17964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17965 }
17966 arg2 = reinterpret_cast< wxFileType * >(argp2);
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 result = (bool)(arg1)->Unassociate(arg2);
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 {
17974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17975 }
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17983 PyObject *resultobj = 0;
17984 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17985 void *argp1 = 0 ;
17986 int res1 = 0 ;
17987 PyObject *swig_obj[1] ;
17988
17989 if (!args) SWIG_fail;
17990 swig_obj[0] = args;
17991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17992 if (!SWIG_IsOK(res1)) {
17993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17994 }
17995 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17996 {
17997 PyThreadState* __tstate = wxPyBeginAllowThreads();
17998 delete arg1;
17999
18000 wxPyEndAllowThreads(__tstate);
18001 if (PyErr_Occurred()) SWIG_fail;
18002 }
18003 resultobj = SWIG_Py_Void();
18004 return resultobj;
18005 fail:
18006 return NULL;
18007 }
18008
18009
18010 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18011 PyObject *obj;
18012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18013 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18014 return SWIG_Py_Void();
18015 }
18016
18017 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18018 return SWIG_Python_InitShadowInstance(args);
18019 }
18020
18021 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18022 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18023 return 1;
18024 }
18025
18026
18027 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18028 PyObject *pyobj = 0;
18029
18030 {
18031 #if wxUSE_UNICODE
18032 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18033 #else
18034 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18035 #endif
18036 }
18037 return pyobj;
18038 }
18039
18040
18041 SWIGINTERN int ART_MENU_set(PyObject *) {
18042 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18043 return 1;
18044 }
18045
18046
18047 SWIGINTERN PyObject *ART_MENU_get(void) {
18048 PyObject *pyobj = 0;
18049
18050 {
18051 #if wxUSE_UNICODE
18052 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18053 #else
18054 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18055 #endif
18056 }
18057 return pyobj;
18058 }
18059
18060
18061 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18062 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18063 return 1;
18064 }
18065
18066
18067 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18068 PyObject *pyobj = 0;
18069
18070 {
18071 #if wxUSE_UNICODE
18072 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18073 #else
18074 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18075 #endif
18076 }
18077 return pyobj;
18078 }
18079
18080
18081 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18082 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18083 return 1;
18084 }
18085
18086
18087 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18088 PyObject *pyobj = 0;
18089
18090 {
18091 #if wxUSE_UNICODE
18092 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18093 #else
18094 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18095 #endif
18096 }
18097 return pyobj;
18098 }
18099
18100
18101 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18102 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18103 return 1;
18104 }
18105
18106
18107 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18108 PyObject *pyobj = 0;
18109
18110 {
18111 #if wxUSE_UNICODE
18112 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18113 #else
18114 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18115 #endif
18116 }
18117 return pyobj;
18118 }
18119
18120
18121 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18122 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18123 return 1;
18124 }
18125
18126
18127 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18128 PyObject *pyobj = 0;
18129
18130 {
18131 #if wxUSE_UNICODE
18132 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18133 #else
18134 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18135 #endif
18136 }
18137 return pyobj;
18138 }
18139
18140
18141 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18142 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18143 return 1;
18144 }
18145
18146
18147 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18148 PyObject *pyobj = 0;
18149
18150 {
18151 #if wxUSE_UNICODE
18152 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18153 #else
18154 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18155 #endif
18156 }
18157 return pyobj;
18158 }
18159
18160
18161 SWIGINTERN int ART_OTHER_set(PyObject *) {
18162 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18163 return 1;
18164 }
18165
18166
18167 SWIGINTERN PyObject *ART_OTHER_get(void) {
18168 PyObject *pyobj = 0;
18169
18170 {
18171 #if wxUSE_UNICODE
18172 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18173 #else
18174 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18175 #endif
18176 }
18177 return pyobj;
18178 }
18179
18180
18181 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18182 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18183 return 1;
18184 }
18185
18186
18187 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18188 PyObject *pyobj = 0;
18189
18190 {
18191 #if wxUSE_UNICODE
18192 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18193 #else
18194 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18195 #endif
18196 }
18197 return pyobj;
18198 }
18199
18200
18201 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18202 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18203 return 1;
18204 }
18205
18206
18207 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18208 PyObject *pyobj = 0;
18209
18210 {
18211 #if wxUSE_UNICODE
18212 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18213 #else
18214 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18215 #endif
18216 }
18217 return pyobj;
18218 }
18219
18220
18221 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18222 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18223 return 1;
18224 }
18225
18226
18227 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18228 PyObject *pyobj = 0;
18229
18230 {
18231 #if wxUSE_UNICODE
18232 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18233 #else
18234 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18235 #endif
18236 }
18237 return pyobj;
18238 }
18239
18240
18241 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18242 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18243 return 1;
18244 }
18245
18246
18247 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18248 PyObject *pyobj = 0;
18249
18250 {
18251 #if wxUSE_UNICODE
18252 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18253 #else
18254 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18255 #endif
18256 }
18257 return pyobj;
18258 }
18259
18260
18261 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18262 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18263 return 1;
18264 }
18265
18266
18267 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18268 PyObject *pyobj = 0;
18269
18270 {
18271 #if wxUSE_UNICODE
18272 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18273 #else
18274 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18275 #endif
18276 }
18277 return pyobj;
18278 }
18279
18280
18281 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18282 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18283 return 1;
18284 }
18285
18286
18287 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18288 PyObject *pyobj = 0;
18289
18290 {
18291 #if wxUSE_UNICODE
18292 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18293 #else
18294 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18295 #endif
18296 }
18297 return pyobj;
18298 }
18299
18300
18301 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18302 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18303 return 1;
18304 }
18305
18306
18307 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18308 PyObject *pyobj = 0;
18309
18310 {
18311 #if wxUSE_UNICODE
18312 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18313 #else
18314 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18315 #endif
18316 }
18317 return pyobj;
18318 }
18319
18320
18321 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18322 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18323 return 1;
18324 }
18325
18326
18327 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18328 PyObject *pyobj = 0;
18329
18330 {
18331 #if wxUSE_UNICODE
18332 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18333 #else
18334 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18335 #endif
18336 }
18337 return pyobj;
18338 }
18339
18340
18341 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18342 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18343 return 1;
18344 }
18345
18346
18347 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18348 PyObject *pyobj = 0;
18349
18350 {
18351 #if wxUSE_UNICODE
18352 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18353 #else
18354 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18355 #endif
18356 }
18357 return pyobj;
18358 }
18359
18360
18361 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18362 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18363 return 1;
18364 }
18365
18366
18367 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18368 PyObject *pyobj = 0;
18369
18370 {
18371 #if wxUSE_UNICODE
18372 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18373 #else
18374 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18375 #endif
18376 }
18377 return pyobj;
18378 }
18379
18380
18381 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18382 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18383 return 1;
18384 }
18385
18386
18387 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18388 PyObject *pyobj = 0;
18389
18390 {
18391 #if wxUSE_UNICODE
18392 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18393 #else
18394 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18395 #endif
18396 }
18397 return pyobj;
18398 }
18399
18400
18401 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18402 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18403 return 1;
18404 }
18405
18406
18407 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18408 PyObject *pyobj = 0;
18409
18410 {
18411 #if wxUSE_UNICODE
18412 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18413 #else
18414 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18415 #endif
18416 }
18417 return pyobj;
18418 }
18419
18420
18421 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18422 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18423 return 1;
18424 }
18425
18426
18427 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18428 PyObject *pyobj = 0;
18429
18430 {
18431 #if wxUSE_UNICODE
18432 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18433 #else
18434 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18435 #endif
18436 }
18437 return pyobj;
18438 }
18439
18440
18441 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18442 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18443 return 1;
18444 }
18445
18446
18447 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18448 PyObject *pyobj = 0;
18449
18450 {
18451 #if wxUSE_UNICODE
18452 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18453 #else
18454 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18455 #endif
18456 }
18457 return pyobj;
18458 }
18459
18460
18461 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18462 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18463 return 1;
18464 }
18465
18466
18467 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18468 PyObject *pyobj = 0;
18469
18470 {
18471 #if wxUSE_UNICODE
18472 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18473 #else
18474 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18475 #endif
18476 }
18477 return pyobj;
18478 }
18479
18480
18481 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18482 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18483 return 1;
18484 }
18485
18486
18487 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18488 PyObject *pyobj = 0;
18489
18490 {
18491 #if wxUSE_UNICODE
18492 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18493 #else
18494 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18495 #endif
18496 }
18497 return pyobj;
18498 }
18499
18500
18501 SWIGINTERN int ART_PRINT_set(PyObject *) {
18502 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18503 return 1;
18504 }
18505
18506
18507 SWIGINTERN PyObject *ART_PRINT_get(void) {
18508 PyObject *pyobj = 0;
18509
18510 {
18511 #if wxUSE_UNICODE
18512 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18513 #else
18514 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18515 #endif
18516 }
18517 return pyobj;
18518 }
18519
18520
18521 SWIGINTERN int ART_HELP_set(PyObject *) {
18522 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18523 return 1;
18524 }
18525
18526
18527 SWIGINTERN PyObject *ART_HELP_get(void) {
18528 PyObject *pyobj = 0;
18529
18530 {
18531 #if wxUSE_UNICODE
18532 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18533 #else
18534 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18535 #endif
18536 }
18537 return pyobj;
18538 }
18539
18540
18541 SWIGINTERN int ART_TIP_set(PyObject *) {
18542 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18543 return 1;
18544 }
18545
18546
18547 SWIGINTERN PyObject *ART_TIP_get(void) {
18548 PyObject *pyobj = 0;
18549
18550 {
18551 #if wxUSE_UNICODE
18552 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18553 #else
18554 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18555 #endif
18556 }
18557 return pyobj;
18558 }
18559
18560
18561 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18562 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18563 return 1;
18564 }
18565
18566
18567 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18568 PyObject *pyobj = 0;
18569
18570 {
18571 #if wxUSE_UNICODE
18572 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18573 #else
18574 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18575 #endif
18576 }
18577 return pyobj;
18578 }
18579
18580
18581 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18582 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18583 return 1;
18584 }
18585
18586
18587 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18588 PyObject *pyobj = 0;
18589
18590 {
18591 #if wxUSE_UNICODE
18592 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18593 #else
18594 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18595 #endif
18596 }
18597 return pyobj;
18598 }
18599
18600
18601 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18602 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18603 return 1;
18604 }
18605
18606
18607 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18608 PyObject *pyobj = 0;
18609
18610 {
18611 #if wxUSE_UNICODE
18612 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18613 #else
18614 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18615 #endif
18616 }
18617 return pyobj;
18618 }
18619
18620
18621 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18622 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18623 return 1;
18624 }
18625
18626
18627 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18628 PyObject *pyobj = 0;
18629
18630 {
18631 #if wxUSE_UNICODE
18632 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18633 #else
18634 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18635 #endif
18636 }
18637 return pyobj;
18638 }
18639
18640
18641 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18642 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18643 return 1;
18644 }
18645
18646
18647 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18648 PyObject *pyobj = 0;
18649
18650 {
18651 #if wxUSE_UNICODE
18652 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18653 #else
18654 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18655 #endif
18656 }
18657 return pyobj;
18658 }
18659
18660
18661 SWIGINTERN int ART_CDROM_set(PyObject *) {
18662 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18663 return 1;
18664 }
18665
18666
18667 SWIGINTERN PyObject *ART_CDROM_get(void) {
18668 PyObject *pyobj = 0;
18669
18670 {
18671 #if wxUSE_UNICODE
18672 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18673 #else
18674 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18675 #endif
18676 }
18677 return pyobj;
18678 }
18679
18680
18681 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18682 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18683 return 1;
18684 }
18685
18686
18687 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18688 PyObject *pyobj = 0;
18689
18690 {
18691 #if wxUSE_UNICODE
18692 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18693 #else
18694 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18695 #endif
18696 }
18697 return pyobj;
18698 }
18699
18700
18701 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18702 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18703 return 1;
18704 }
18705
18706
18707 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18708 PyObject *pyobj = 0;
18709
18710 {
18711 #if wxUSE_UNICODE
18712 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18713 #else
18714 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18715 #endif
18716 }
18717 return pyobj;
18718 }
18719
18720
18721 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18722 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18723 return 1;
18724 }
18725
18726
18727 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18728 PyObject *pyobj = 0;
18729
18730 {
18731 #if wxUSE_UNICODE
18732 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18733 #else
18734 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18735 #endif
18736 }
18737 return pyobj;
18738 }
18739
18740
18741 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18742 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18743 return 1;
18744 }
18745
18746
18747 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18748 PyObject *pyobj = 0;
18749
18750 {
18751 #if wxUSE_UNICODE
18752 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18753 #else
18754 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18755 #endif
18756 }
18757 return pyobj;
18758 }
18759
18760
18761 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18762 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18763 return 1;
18764 }
18765
18766
18767 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18768 PyObject *pyobj = 0;
18769
18770 {
18771 #if wxUSE_UNICODE
18772 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18773 #else
18774 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18775 #endif
18776 }
18777 return pyobj;
18778 }
18779
18780
18781 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18782 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18783 return 1;
18784 }
18785
18786
18787 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18788 PyObject *pyobj = 0;
18789
18790 {
18791 #if wxUSE_UNICODE
18792 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18793 #else
18794 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18795 #endif
18796 }
18797 return pyobj;
18798 }
18799
18800
18801 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18802 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18803 return 1;
18804 }
18805
18806
18807 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18808 PyObject *pyobj = 0;
18809
18810 {
18811 #if wxUSE_UNICODE
18812 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18813 #else
18814 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18815 #endif
18816 }
18817 return pyobj;
18818 }
18819
18820
18821 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18822 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18823 return 1;
18824 }
18825
18826
18827 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18828 PyObject *pyobj = 0;
18829
18830 {
18831 #if wxUSE_UNICODE
18832 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18833 #else
18834 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18835 #endif
18836 }
18837 return pyobj;
18838 }
18839
18840
18841 SWIGINTERN int ART_ERROR_set(PyObject *) {
18842 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18843 return 1;
18844 }
18845
18846
18847 SWIGINTERN PyObject *ART_ERROR_get(void) {
18848 PyObject *pyobj = 0;
18849
18850 {
18851 #if wxUSE_UNICODE
18852 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18853 #else
18854 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18855 #endif
18856 }
18857 return pyobj;
18858 }
18859
18860
18861 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18862 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18863 return 1;
18864 }
18865
18866
18867 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18868 PyObject *pyobj = 0;
18869
18870 {
18871 #if wxUSE_UNICODE
18872 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18873 #else
18874 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18875 #endif
18876 }
18877 return pyobj;
18878 }
18879
18880
18881 SWIGINTERN int ART_WARNING_set(PyObject *) {
18882 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18883 return 1;
18884 }
18885
18886
18887 SWIGINTERN PyObject *ART_WARNING_get(void) {
18888 PyObject *pyobj = 0;
18889
18890 {
18891 #if wxUSE_UNICODE
18892 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18893 #else
18894 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18895 #endif
18896 }
18897 return pyobj;
18898 }
18899
18900
18901 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18902 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18903 return 1;
18904 }
18905
18906
18907 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18908 PyObject *pyobj = 0;
18909
18910 {
18911 #if wxUSE_UNICODE
18912 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18913 #else
18914 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18915 #endif
18916 }
18917 return pyobj;
18918 }
18919
18920
18921 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18922 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18923 return 1;
18924 }
18925
18926
18927 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18928 PyObject *pyobj = 0;
18929
18930 {
18931 #if wxUSE_UNICODE
18932 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18933 #else
18934 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18935 #endif
18936 }
18937 return pyobj;
18938 }
18939
18940
18941 SWIGINTERN int ART_COPY_set(PyObject *) {
18942 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18943 return 1;
18944 }
18945
18946
18947 SWIGINTERN PyObject *ART_COPY_get(void) {
18948 PyObject *pyobj = 0;
18949
18950 {
18951 #if wxUSE_UNICODE
18952 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18953 #else
18954 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18955 #endif
18956 }
18957 return pyobj;
18958 }
18959
18960
18961 SWIGINTERN int ART_CUT_set(PyObject *) {
18962 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18963 return 1;
18964 }
18965
18966
18967 SWIGINTERN PyObject *ART_CUT_get(void) {
18968 PyObject *pyobj = 0;
18969
18970 {
18971 #if wxUSE_UNICODE
18972 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18973 #else
18974 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18975 #endif
18976 }
18977 return pyobj;
18978 }
18979
18980
18981 SWIGINTERN int ART_PASTE_set(PyObject *) {
18982 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18983 return 1;
18984 }
18985
18986
18987 SWIGINTERN PyObject *ART_PASTE_get(void) {
18988 PyObject *pyobj = 0;
18989
18990 {
18991 #if wxUSE_UNICODE
18992 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18993 #else
18994 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18995 #endif
18996 }
18997 return pyobj;
18998 }
18999
19000
19001 SWIGINTERN int ART_DELETE_set(PyObject *) {
19002 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19003 return 1;
19004 }
19005
19006
19007 SWIGINTERN PyObject *ART_DELETE_get(void) {
19008 PyObject *pyobj = 0;
19009
19010 {
19011 #if wxUSE_UNICODE
19012 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19013 #else
19014 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19015 #endif
19016 }
19017 return pyobj;
19018 }
19019
19020
19021 SWIGINTERN int ART_NEW_set(PyObject *) {
19022 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19023 return 1;
19024 }
19025
19026
19027 SWIGINTERN PyObject *ART_NEW_get(void) {
19028 PyObject *pyobj = 0;
19029
19030 {
19031 #if wxUSE_UNICODE
19032 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19033 #else
19034 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19035 #endif
19036 }
19037 return pyobj;
19038 }
19039
19040
19041 SWIGINTERN int ART_UNDO_set(PyObject *) {
19042 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19043 return 1;
19044 }
19045
19046
19047 SWIGINTERN PyObject *ART_UNDO_get(void) {
19048 PyObject *pyobj = 0;
19049
19050 {
19051 #if wxUSE_UNICODE
19052 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19053 #else
19054 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19055 #endif
19056 }
19057 return pyobj;
19058 }
19059
19060
19061 SWIGINTERN int ART_REDO_set(PyObject *) {
19062 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19063 return 1;
19064 }
19065
19066
19067 SWIGINTERN PyObject *ART_REDO_get(void) {
19068 PyObject *pyobj = 0;
19069
19070 {
19071 #if wxUSE_UNICODE
19072 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19073 #else
19074 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19075 #endif
19076 }
19077 return pyobj;
19078 }
19079
19080
19081 SWIGINTERN int ART_QUIT_set(PyObject *) {
19082 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19083 return 1;
19084 }
19085
19086
19087 SWIGINTERN PyObject *ART_QUIT_get(void) {
19088 PyObject *pyobj = 0;
19089
19090 {
19091 #if wxUSE_UNICODE
19092 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19093 #else
19094 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19095 #endif
19096 }
19097 return pyobj;
19098 }
19099
19100
19101 SWIGINTERN int ART_FIND_set(PyObject *) {
19102 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19103 return 1;
19104 }
19105
19106
19107 SWIGINTERN PyObject *ART_FIND_get(void) {
19108 PyObject *pyobj = 0;
19109
19110 {
19111 #if wxUSE_UNICODE
19112 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19113 #else
19114 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19115 #endif
19116 }
19117 return pyobj;
19118 }
19119
19120
19121 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19122 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19123 return 1;
19124 }
19125
19126
19127 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19128 PyObject *pyobj = 0;
19129
19130 {
19131 #if wxUSE_UNICODE
19132 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19133 #else
19134 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19135 #endif
19136 }
19137 return pyobj;
19138 }
19139
19140
19141 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19142 PyObject *resultobj = 0;
19143 wxPyArtProvider *result = 0 ;
19144
19145 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19146 {
19147 if (!wxPyCheckForApp()) SWIG_fail;
19148 PyThreadState* __tstate = wxPyBeginAllowThreads();
19149 result = (wxPyArtProvider *)new wxPyArtProvider();
19150 wxPyEndAllowThreads(__tstate);
19151 if (PyErr_Occurred()) SWIG_fail;
19152 }
19153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19154 return resultobj;
19155 fail:
19156 return NULL;
19157 }
19158
19159
19160 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19161 PyObject *resultobj = 0;
19162 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 PyObject *swig_obj[1] ;
19166
19167 if (!args) SWIG_fail;
19168 swig_obj[0] = args;
19169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19172 }
19173 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 delete arg1;
19177
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 resultobj = SWIG_Py_Void();
19182 return resultobj;
19183 fail:
19184 return NULL;
19185 }
19186
19187
19188 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19189 PyObject *resultobj = 0;
19190 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19191 PyObject *arg2 = (PyObject *) 0 ;
19192 PyObject *arg3 = (PyObject *) 0 ;
19193 void *argp1 = 0 ;
19194 int res1 = 0 ;
19195 PyObject * obj0 = 0 ;
19196 PyObject * obj1 = 0 ;
19197 PyObject * obj2 = 0 ;
19198 char * kwnames[] = {
19199 (char *) "self",(char *) "self",(char *) "_class", NULL
19200 };
19201
19202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19204 if (!SWIG_IsOK(res1)) {
19205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19206 }
19207 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19208 arg2 = obj1;
19209 arg3 = obj2;
19210 {
19211 PyThreadState* __tstate = wxPyBeginAllowThreads();
19212 (arg1)->_setCallbackInfo(arg2,arg3);
19213 wxPyEndAllowThreads(__tstate);
19214 if (PyErr_Occurred()) SWIG_fail;
19215 }
19216 resultobj = SWIG_Py_Void();
19217 return resultobj;
19218 fail:
19219 return NULL;
19220 }
19221
19222
19223 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19224 PyObject *resultobj = 0;
19225 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19226 int res1 = 0 ;
19227 PyObject * obj0 = 0 ;
19228 char * kwnames[] = {
19229 (char *) "provider", NULL
19230 };
19231
19232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19233 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19234 if (!SWIG_IsOK(res1)) {
19235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19236 }
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 wxPyArtProvider::PushProvider(arg1);
19240 wxPyEndAllowThreads(__tstate);
19241 if (PyErr_Occurred()) SWIG_fail;
19242 }
19243 resultobj = SWIG_Py_Void();
19244 return resultobj;
19245 fail:
19246 return NULL;
19247 }
19248
19249
19250 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19251 PyObject *resultobj = 0;
19252 bool result;
19253
19254 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19255 {
19256 PyThreadState* __tstate = wxPyBeginAllowThreads();
19257 result = (bool)wxPyArtProvider::PopProvider();
19258 wxPyEndAllowThreads(__tstate);
19259 if (PyErr_Occurred()) SWIG_fail;
19260 }
19261 {
19262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19263 }
19264 return resultobj;
19265 fail:
19266 return NULL;
19267 }
19268
19269
19270 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19271 PyObject *resultobj = 0;
19272 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19273 bool result;
19274 void *argp1 = 0 ;
19275 int res1 = 0 ;
19276 PyObject * obj0 = 0 ;
19277 char * kwnames[] = {
19278 (char *) "provider", NULL
19279 };
19280
19281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19283 if (!SWIG_IsOK(res1)) {
19284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19285 }
19286 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19287 {
19288 PyThreadState* __tstate = wxPyBeginAllowThreads();
19289 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19290 wxPyEndAllowThreads(__tstate);
19291 if (PyErr_Occurred()) SWIG_fail;
19292 }
19293 {
19294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19295 }
19296 return resultobj;
19297 fail:
19298 return NULL;
19299 }
19300
19301
19302 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19303 PyObject *resultobj = 0;
19304 wxString *arg1 = 0 ;
19305 wxString const &arg2_defvalue = wxPyART_OTHER ;
19306 wxString *arg2 = (wxString *) &arg2_defvalue ;
19307 wxSize const &arg3_defvalue = wxDefaultSize ;
19308 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19309 wxBitmap result;
19310 bool temp1 = false ;
19311 bool temp2 = false ;
19312 wxSize temp3 ;
19313 PyObject * obj0 = 0 ;
19314 PyObject * obj1 = 0 ;
19315 PyObject * obj2 = 0 ;
19316 char * kwnames[] = {
19317 (char *) "id",(char *) "client",(char *) "size", NULL
19318 };
19319
19320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19321 {
19322 arg1 = wxString_in_helper(obj0);
19323 if (arg1 == NULL) SWIG_fail;
19324 temp1 = true;
19325 }
19326 if (obj1) {
19327 {
19328 arg2 = wxString_in_helper(obj1);
19329 if (arg2 == NULL) SWIG_fail;
19330 temp2 = true;
19331 }
19332 }
19333 if (obj2) {
19334 {
19335 arg3 = &temp3;
19336 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19337 }
19338 }
19339 {
19340 if (!wxPyCheckForApp()) SWIG_fail;
19341 PyThreadState* __tstate = wxPyBeginAllowThreads();
19342 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19347 {
19348 if (temp1)
19349 delete arg1;
19350 }
19351 {
19352 if (temp2)
19353 delete arg2;
19354 }
19355 return resultobj;
19356 fail:
19357 {
19358 if (temp1)
19359 delete arg1;
19360 }
19361 {
19362 if (temp2)
19363 delete arg2;
19364 }
19365 return NULL;
19366 }
19367
19368
19369 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19370 PyObject *resultobj = 0;
19371 wxString *arg1 = 0 ;
19372 wxString const &arg2_defvalue = wxPyART_OTHER ;
19373 wxString *arg2 = (wxString *) &arg2_defvalue ;
19374 wxSize const &arg3_defvalue = wxDefaultSize ;
19375 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19376 wxIcon result;
19377 bool temp1 = false ;
19378 bool temp2 = false ;
19379 wxSize temp3 ;
19380 PyObject * obj0 = 0 ;
19381 PyObject * obj1 = 0 ;
19382 PyObject * obj2 = 0 ;
19383 char * kwnames[] = {
19384 (char *) "id",(char *) "client",(char *) "size", NULL
19385 };
19386
19387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19388 {
19389 arg1 = wxString_in_helper(obj0);
19390 if (arg1 == NULL) SWIG_fail;
19391 temp1 = true;
19392 }
19393 if (obj1) {
19394 {
19395 arg2 = wxString_in_helper(obj1);
19396 if (arg2 == NULL) SWIG_fail;
19397 temp2 = true;
19398 }
19399 }
19400 if (obj2) {
19401 {
19402 arg3 = &temp3;
19403 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19404 }
19405 }
19406 {
19407 if (!wxPyCheckForApp()) SWIG_fail;
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19414 {
19415 if (temp1)
19416 delete arg1;
19417 }
19418 {
19419 if (temp2)
19420 delete arg2;
19421 }
19422 return resultobj;
19423 fail:
19424 {
19425 if (temp1)
19426 delete arg1;
19427 }
19428 {
19429 if (temp2)
19430 delete arg2;
19431 }
19432 return NULL;
19433 }
19434
19435
19436 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj = 0;
19438 wxString *arg1 = 0 ;
19439 bool arg2 = (bool) false ;
19440 wxSize result;
19441 bool temp1 = false ;
19442 bool val2 ;
19443 int ecode2 = 0 ;
19444 PyObject * obj0 = 0 ;
19445 PyObject * obj1 = 0 ;
19446 char * kwnames[] = {
19447 (char *) "client",(char *) "platform_dependent", NULL
19448 };
19449
19450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19451 {
19452 arg1 = wxString_in_helper(obj0);
19453 if (arg1 == NULL) SWIG_fail;
19454 temp1 = true;
19455 }
19456 if (obj1) {
19457 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19458 if (!SWIG_IsOK(ecode2)) {
19459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19460 }
19461 arg2 = static_cast< bool >(val2);
19462 }
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19470 {
19471 if (temp1)
19472 delete arg1;
19473 }
19474 return resultobj;
19475 fail:
19476 {
19477 if (temp1)
19478 delete arg1;
19479 }
19480 return NULL;
19481 }
19482
19483
19484 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19485 PyObject *resultobj = 0;
19486 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19487 void *argp1 = 0 ;
19488 int res1 = 0 ;
19489 PyObject *swig_obj[1] ;
19490
19491 if (!args) SWIG_fail;
19492 swig_obj[0] = args;
19493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19494 if (!SWIG_IsOK(res1)) {
19495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19496 }
19497 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 wxPyArtProvider_Destroy(arg1);
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 resultobj = SWIG_Py_Void();
19505 return resultobj;
19506 fail:
19507 return NULL;
19508 }
19509
19510
19511 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19512 PyObject *obj;
19513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19514 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19515 return SWIG_Py_Void();
19516 }
19517
19518 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19519 return SWIG_Python_InitShadowInstance(args);
19520 }
19521
19522 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19523 PyObject *resultobj = 0;
19524 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19525 void *argp1 = 0 ;
19526 int res1 = 0 ;
19527 PyObject *swig_obj[1] ;
19528
19529 if (!args) SWIG_fail;
19530 swig_obj[0] = args;
19531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19532 if (!SWIG_IsOK(res1)) {
19533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19534 }
19535 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19536 {
19537 PyThreadState* __tstate = wxPyBeginAllowThreads();
19538 delete arg1;
19539
19540 wxPyEndAllowThreads(__tstate);
19541 if (PyErr_Occurred()) SWIG_fail;
19542 }
19543 resultobj = SWIG_Py_Void();
19544 return resultobj;
19545 fail:
19546 return NULL;
19547 }
19548
19549
19550 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19551 PyObject *resultobj = 0;
19552 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19553 wxConfigBase *result = 0 ;
19554 int res1 = 0 ;
19555 PyObject * obj0 = 0 ;
19556 char * kwnames[] = {
19557 (char *) "config", NULL
19558 };
19559
19560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19561 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19562 if (!SWIG_IsOK(res1)) {
19563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19564 }
19565 {
19566 PyThreadState* __tstate = wxPyBeginAllowThreads();
19567 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19568 wxPyEndAllowThreads(__tstate);
19569 if (PyErr_Occurred()) SWIG_fail;
19570 }
19571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19572 return resultobj;
19573 fail:
19574 return NULL;
19575 }
19576
19577
19578 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19579 PyObject *resultobj = 0;
19580 bool arg1 = (bool) true ;
19581 wxConfigBase *result = 0 ;
19582 bool val1 ;
19583 int ecode1 = 0 ;
19584 PyObject * obj0 = 0 ;
19585 char * kwnames[] = {
19586 (char *) "createOnDemand", NULL
19587 };
19588
19589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19590 if (obj0) {
19591 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19592 if (!SWIG_IsOK(ecode1)) {
19593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19594 }
19595 arg1 = static_cast< bool >(val1);
19596 }
19597 {
19598 PyThreadState* __tstate = wxPyBeginAllowThreads();
19599 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19600 wxPyEndAllowThreads(__tstate);
19601 if (PyErr_Occurred()) SWIG_fail;
19602 }
19603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19604 return resultobj;
19605 fail:
19606 return NULL;
19607 }
19608
19609
19610 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19611 PyObject *resultobj = 0;
19612 wxConfigBase *result = 0 ;
19613
19614 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 result = (wxConfigBase *)wxConfigBase::Create();
19618 wxPyEndAllowThreads(__tstate);
19619 if (PyErr_Occurred()) SWIG_fail;
19620 }
19621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19622 return resultobj;
19623 fail:
19624 return NULL;
19625 }
19626
19627
19628 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19629 PyObject *resultobj = 0;
19630
19631 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19632 {
19633 PyThreadState* __tstate = wxPyBeginAllowThreads();
19634 wxConfigBase::DontCreateOnDemand();
19635 wxPyEndAllowThreads(__tstate);
19636 if (PyErr_Occurred()) SWIG_fail;
19637 }
19638 resultobj = SWIG_Py_Void();
19639 return resultobj;
19640 fail:
19641 return NULL;
19642 }
19643
19644
19645 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19646 PyObject *resultobj = 0;
19647 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19648 wxString *arg2 = 0 ;
19649 void *argp1 = 0 ;
19650 int res1 = 0 ;
19651 bool temp2 = false ;
19652 PyObject * obj0 = 0 ;
19653 PyObject * obj1 = 0 ;
19654 char * kwnames[] = {
19655 (char *) "self",(char *) "path", NULL
19656 };
19657
19658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19660 if (!SWIG_IsOK(res1)) {
19661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19662 }
19663 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19664 {
19665 arg2 = wxString_in_helper(obj1);
19666 if (arg2 == NULL) SWIG_fail;
19667 temp2 = true;
19668 }
19669 {
19670 PyThreadState* __tstate = wxPyBeginAllowThreads();
19671 (arg1)->SetPath((wxString const &)*arg2);
19672 wxPyEndAllowThreads(__tstate);
19673 if (PyErr_Occurred()) SWIG_fail;
19674 }
19675 resultobj = SWIG_Py_Void();
19676 {
19677 if (temp2)
19678 delete arg2;
19679 }
19680 return resultobj;
19681 fail:
19682 {
19683 if (temp2)
19684 delete arg2;
19685 }
19686 return NULL;
19687 }
19688
19689
19690 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19691 PyObject *resultobj = 0;
19692 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19693 wxString *result = 0 ;
19694 void *argp1 = 0 ;
19695 int res1 = 0 ;
19696 PyObject *swig_obj[1] ;
19697
19698 if (!args) SWIG_fail;
19699 swig_obj[0] = args;
19700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19701 if (!SWIG_IsOK(res1)) {
19702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19703 }
19704 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19705 {
19706 PyThreadState* __tstate = wxPyBeginAllowThreads();
19707 {
19708 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19709 result = (wxString *) &_result_ref;
19710 }
19711 wxPyEndAllowThreads(__tstate);
19712 if (PyErr_Occurred()) SWIG_fail;
19713 }
19714 {
19715 #if wxUSE_UNICODE
19716 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19717 #else
19718 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19719 #endif
19720 }
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19728 PyObject *resultobj = 0;
19729 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19730 PyObject *result = 0 ;
19731 void *argp1 = 0 ;
19732 int res1 = 0 ;
19733 PyObject *swig_obj[1] ;
19734
19735 if (!args) SWIG_fail;
19736 swig_obj[0] = args;
19737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19738 if (!SWIG_IsOK(res1)) {
19739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19740 }
19741 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19742 {
19743 PyThreadState* __tstate = wxPyBeginAllowThreads();
19744 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19745 wxPyEndAllowThreads(__tstate);
19746 if (PyErr_Occurred()) SWIG_fail;
19747 }
19748 resultobj = result;
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19756 PyObject *resultobj = 0;
19757 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19758 long arg2 ;
19759 PyObject *result = 0 ;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 long val2 ;
19763 int ecode2 = 0 ;
19764 PyObject * obj0 = 0 ;
19765 PyObject * obj1 = 0 ;
19766 char * kwnames[] = {
19767 (char *) "self",(char *) "index", NULL
19768 };
19769
19770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19772 if (!SWIG_IsOK(res1)) {
19773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19774 }
19775 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19776 ecode2 = SWIG_AsVal_long(obj1, &val2);
19777 if (!SWIG_IsOK(ecode2)) {
19778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19779 }
19780 arg2 = static_cast< long >(val2);
19781 {
19782 PyThreadState* __tstate = wxPyBeginAllowThreads();
19783 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19784 wxPyEndAllowThreads(__tstate);
19785 if (PyErr_Occurred()) SWIG_fail;
19786 }
19787 resultobj = result;
19788 return resultobj;
19789 fail:
19790 return NULL;
19791 }
19792
19793
19794 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19795 PyObject *resultobj = 0;
19796 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19797 PyObject *result = 0 ;
19798 void *argp1 = 0 ;
19799 int res1 = 0 ;
19800 PyObject *swig_obj[1] ;
19801
19802 if (!args) SWIG_fail;
19803 swig_obj[0] = args;
19804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19805 if (!SWIG_IsOK(res1)) {
19806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19807 }
19808 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 resultobj = result;
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19825 long arg2 ;
19826 PyObject *result = 0 ;
19827 void *argp1 = 0 ;
19828 int res1 = 0 ;
19829 long val2 ;
19830 int ecode2 = 0 ;
19831 PyObject * obj0 = 0 ;
19832 PyObject * obj1 = 0 ;
19833 char * kwnames[] = {
19834 (char *) "self",(char *) "index", NULL
19835 };
19836
19837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19839 if (!SWIG_IsOK(res1)) {
19840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19841 }
19842 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19843 ecode2 = SWIG_AsVal_long(obj1, &val2);
19844 if (!SWIG_IsOK(ecode2)) {
19845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19846 }
19847 arg2 = static_cast< long >(val2);
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19851 wxPyEndAllowThreads(__tstate);
19852 if (PyErr_Occurred()) SWIG_fail;
19853 }
19854 resultobj = result;
19855 return resultobj;
19856 fail:
19857 return NULL;
19858 }
19859
19860
19861 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19862 PyObject *resultobj = 0;
19863 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19864 bool arg2 = (bool) false ;
19865 size_t result;
19866 void *argp1 = 0 ;
19867 int res1 = 0 ;
19868 bool val2 ;
19869 int ecode2 = 0 ;
19870 PyObject * obj0 = 0 ;
19871 PyObject * obj1 = 0 ;
19872 char * kwnames[] = {
19873 (char *) "self",(char *) "recursive", NULL
19874 };
19875
19876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19878 if (!SWIG_IsOK(res1)) {
19879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19880 }
19881 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19882 if (obj1) {
19883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19884 if (!SWIG_IsOK(ecode2)) {
19885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19886 }
19887 arg2 = static_cast< bool >(val2);
19888 }
19889 {
19890 PyThreadState* __tstate = wxPyBeginAllowThreads();
19891 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19892 wxPyEndAllowThreads(__tstate);
19893 if (PyErr_Occurred()) SWIG_fail;
19894 }
19895 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19896 return resultobj;
19897 fail:
19898 return NULL;
19899 }
19900
19901
19902 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19903 PyObject *resultobj = 0;
19904 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19905 bool arg2 = (bool) false ;
19906 size_t result;
19907 void *argp1 = 0 ;
19908 int res1 = 0 ;
19909 bool val2 ;
19910 int ecode2 = 0 ;
19911 PyObject * obj0 = 0 ;
19912 PyObject * obj1 = 0 ;
19913 char * kwnames[] = {
19914 (char *) "self",(char *) "recursive", NULL
19915 };
19916
19917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19919 if (!SWIG_IsOK(res1)) {
19920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19921 }
19922 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19923 if (obj1) {
19924 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19925 if (!SWIG_IsOK(ecode2)) {
19926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19927 }
19928 arg2 = static_cast< bool >(val2);
19929 }
19930 {
19931 PyThreadState* __tstate = wxPyBeginAllowThreads();
19932 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19933 wxPyEndAllowThreads(__tstate);
19934 if (PyErr_Occurred()) SWIG_fail;
19935 }
19936 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19937 return resultobj;
19938 fail:
19939 return NULL;
19940 }
19941
19942
19943 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19944 PyObject *resultobj = 0;
19945 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19946 wxString *arg2 = 0 ;
19947 bool result;
19948 void *argp1 = 0 ;
19949 int res1 = 0 ;
19950 bool temp2 = false ;
19951 PyObject * obj0 = 0 ;
19952 PyObject * obj1 = 0 ;
19953 char * kwnames[] = {
19954 (char *) "self",(char *) "name", NULL
19955 };
19956
19957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19959 if (!SWIG_IsOK(res1)) {
19960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19961 }
19962 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19963 {
19964 arg2 = wxString_in_helper(obj1);
19965 if (arg2 == NULL) SWIG_fail;
19966 temp2 = true;
19967 }
19968 {
19969 PyThreadState* __tstate = wxPyBeginAllowThreads();
19970 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 {
19975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19976 }
19977 {
19978 if (temp2)
19979 delete arg2;
19980 }
19981 return resultobj;
19982 fail:
19983 {
19984 if (temp2)
19985 delete arg2;
19986 }
19987 return NULL;
19988 }
19989
19990
19991 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19992 PyObject *resultobj = 0;
19993 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19994 wxString *arg2 = 0 ;
19995 bool result;
19996 void *argp1 = 0 ;
19997 int res1 = 0 ;
19998 bool temp2 = false ;
19999 PyObject * obj0 = 0 ;
20000 PyObject * obj1 = 0 ;
20001 char * kwnames[] = {
20002 (char *) "self",(char *) "name", NULL
20003 };
20004
20005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20007 if (!SWIG_IsOK(res1)) {
20008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20009 }
20010 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20011 {
20012 arg2 = wxString_in_helper(obj1);
20013 if (arg2 == NULL) SWIG_fail;
20014 temp2 = true;
20015 }
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20019 wxPyEndAllowThreads(__tstate);
20020 if (PyErr_Occurred()) SWIG_fail;
20021 }
20022 {
20023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20024 }
20025 {
20026 if (temp2)
20027 delete arg2;
20028 }
20029 return resultobj;
20030 fail:
20031 {
20032 if (temp2)
20033 delete arg2;
20034 }
20035 return NULL;
20036 }
20037
20038
20039 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20040 PyObject *resultobj = 0;
20041 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20042 wxString *arg2 = 0 ;
20043 bool result;
20044 void *argp1 = 0 ;
20045 int res1 = 0 ;
20046 bool temp2 = false ;
20047 PyObject * obj0 = 0 ;
20048 PyObject * obj1 = 0 ;
20049 char * kwnames[] = {
20050 (char *) "self",(char *) "name", NULL
20051 };
20052
20053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20055 if (!SWIG_IsOK(res1)) {
20056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20057 }
20058 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20059 {
20060 arg2 = wxString_in_helper(obj1);
20061 if (arg2 == NULL) SWIG_fail;
20062 temp2 = true;
20063 }
20064 {
20065 PyThreadState* __tstate = wxPyBeginAllowThreads();
20066 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20067 wxPyEndAllowThreads(__tstate);
20068 if (PyErr_Occurred()) SWIG_fail;
20069 }
20070 {
20071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20072 }
20073 {
20074 if (temp2)
20075 delete arg2;
20076 }
20077 return resultobj;
20078 fail:
20079 {
20080 if (temp2)
20081 delete arg2;
20082 }
20083 return NULL;
20084 }
20085
20086
20087 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20088 PyObject *resultobj = 0;
20089 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20090 wxString *arg2 = 0 ;
20091 wxConfigBase::EntryType result;
20092 void *argp1 = 0 ;
20093 int res1 = 0 ;
20094 bool temp2 = false ;
20095 PyObject * obj0 = 0 ;
20096 PyObject * obj1 = 0 ;
20097 char * kwnames[] = {
20098 (char *) "self",(char *) "name", NULL
20099 };
20100
20101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20103 if (!SWIG_IsOK(res1)) {
20104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20105 }
20106 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20107 {
20108 arg2 = wxString_in_helper(obj1);
20109 if (arg2 == NULL) SWIG_fail;
20110 temp2 = true;
20111 }
20112 {
20113 PyThreadState* __tstate = wxPyBeginAllowThreads();
20114 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20115 wxPyEndAllowThreads(__tstate);
20116 if (PyErr_Occurred()) SWIG_fail;
20117 }
20118 resultobj = SWIG_From_int(static_cast< int >(result));
20119 {
20120 if (temp2)
20121 delete arg2;
20122 }
20123 return resultobj;
20124 fail:
20125 {
20126 if (temp2)
20127 delete arg2;
20128 }
20129 return NULL;
20130 }
20131
20132
20133 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20134 PyObject *resultobj = 0;
20135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20136 wxString *arg2 = 0 ;
20137 wxString const &arg3_defvalue = wxPyEmptyString ;
20138 wxString *arg3 = (wxString *) &arg3_defvalue ;
20139 wxString result;
20140 void *argp1 = 0 ;
20141 int res1 = 0 ;
20142 bool temp2 = false ;
20143 bool temp3 = false ;
20144 PyObject * obj0 = 0 ;
20145 PyObject * obj1 = 0 ;
20146 PyObject * obj2 = 0 ;
20147 char * kwnames[] = {
20148 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20149 };
20150
20151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20153 if (!SWIG_IsOK(res1)) {
20154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20155 }
20156 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20157 {
20158 arg2 = wxString_in_helper(obj1);
20159 if (arg2 == NULL) SWIG_fail;
20160 temp2 = true;
20161 }
20162 if (obj2) {
20163 {
20164 arg3 = wxString_in_helper(obj2);
20165 if (arg3 == NULL) SWIG_fail;
20166 temp3 = true;
20167 }
20168 }
20169 {
20170 PyThreadState* __tstate = wxPyBeginAllowThreads();
20171 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 {
20176 #if wxUSE_UNICODE
20177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20178 #else
20179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20180 #endif
20181 }
20182 {
20183 if (temp2)
20184 delete arg2;
20185 }
20186 {
20187 if (temp3)
20188 delete arg3;
20189 }
20190 return resultobj;
20191 fail:
20192 {
20193 if (temp2)
20194 delete arg2;
20195 }
20196 {
20197 if (temp3)
20198 delete arg3;
20199 }
20200 return NULL;
20201 }
20202
20203
20204 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20205 PyObject *resultobj = 0;
20206 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20207 wxString *arg2 = 0 ;
20208 long arg3 = (long) 0 ;
20209 long result;
20210 void *argp1 = 0 ;
20211 int res1 = 0 ;
20212 bool temp2 = false ;
20213 long val3 ;
20214 int ecode3 = 0 ;
20215 PyObject * obj0 = 0 ;
20216 PyObject * obj1 = 0 ;
20217 PyObject * obj2 = 0 ;
20218 char * kwnames[] = {
20219 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20220 };
20221
20222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20224 if (!SWIG_IsOK(res1)) {
20225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20226 }
20227 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20228 {
20229 arg2 = wxString_in_helper(obj1);
20230 if (arg2 == NULL) SWIG_fail;
20231 temp2 = true;
20232 }
20233 if (obj2) {
20234 ecode3 = SWIG_AsVal_long(obj2, &val3);
20235 if (!SWIG_IsOK(ecode3)) {
20236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20237 }
20238 arg3 = static_cast< long >(val3);
20239 }
20240 {
20241 PyThreadState* __tstate = wxPyBeginAllowThreads();
20242 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20243 wxPyEndAllowThreads(__tstate);
20244 if (PyErr_Occurred()) SWIG_fail;
20245 }
20246 resultobj = SWIG_From_long(static_cast< long >(result));
20247 {
20248 if (temp2)
20249 delete arg2;
20250 }
20251 return resultobj;
20252 fail:
20253 {
20254 if (temp2)
20255 delete arg2;
20256 }
20257 return NULL;
20258 }
20259
20260
20261 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20262 PyObject *resultobj = 0;
20263 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20264 wxString *arg2 = 0 ;
20265 double arg3 = (double) 0.0 ;
20266 double result;
20267 void *argp1 = 0 ;
20268 int res1 = 0 ;
20269 bool temp2 = false ;
20270 double val3 ;
20271 int ecode3 = 0 ;
20272 PyObject * obj0 = 0 ;
20273 PyObject * obj1 = 0 ;
20274 PyObject * obj2 = 0 ;
20275 char * kwnames[] = {
20276 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20277 };
20278
20279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20281 if (!SWIG_IsOK(res1)) {
20282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20283 }
20284 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20285 {
20286 arg2 = wxString_in_helper(obj1);
20287 if (arg2 == NULL) SWIG_fail;
20288 temp2 = true;
20289 }
20290 if (obj2) {
20291 ecode3 = SWIG_AsVal_double(obj2, &val3);
20292 if (!SWIG_IsOK(ecode3)) {
20293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20294 }
20295 arg3 = static_cast< double >(val3);
20296 }
20297 {
20298 PyThreadState* __tstate = wxPyBeginAllowThreads();
20299 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20300 wxPyEndAllowThreads(__tstate);
20301 if (PyErr_Occurred()) SWIG_fail;
20302 }
20303 resultobj = SWIG_From_double(static_cast< double >(result));
20304 {
20305 if (temp2)
20306 delete arg2;
20307 }
20308 return resultobj;
20309 fail:
20310 {
20311 if (temp2)
20312 delete arg2;
20313 }
20314 return NULL;
20315 }
20316
20317
20318 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20319 PyObject *resultobj = 0;
20320 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20321 wxString *arg2 = 0 ;
20322 bool arg3 = (bool) false ;
20323 bool result;
20324 void *argp1 = 0 ;
20325 int res1 = 0 ;
20326 bool temp2 = false ;
20327 bool val3 ;
20328 int ecode3 = 0 ;
20329 PyObject * obj0 = 0 ;
20330 PyObject * obj1 = 0 ;
20331 PyObject * obj2 = 0 ;
20332 char * kwnames[] = {
20333 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20334 };
20335
20336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20338 if (!SWIG_IsOK(res1)) {
20339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20340 }
20341 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20342 {
20343 arg2 = wxString_in_helper(obj1);
20344 if (arg2 == NULL) SWIG_fail;
20345 temp2 = true;
20346 }
20347 if (obj2) {
20348 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20349 if (!SWIG_IsOK(ecode3)) {
20350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20351 }
20352 arg3 = static_cast< bool >(val3);
20353 }
20354 {
20355 PyThreadState* __tstate = wxPyBeginAllowThreads();
20356 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20357 wxPyEndAllowThreads(__tstate);
20358 if (PyErr_Occurred()) SWIG_fail;
20359 }
20360 {
20361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20362 }
20363 {
20364 if (temp2)
20365 delete arg2;
20366 }
20367 return resultobj;
20368 fail:
20369 {
20370 if (temp2)
20371 delete arg2;
20372 }
20373 return NULL;
20374 }
20375
20376
20377 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20378 PyObject *resultobj = 0;
20379 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20380 wxString *arg2 = 0 ;
20381 wxString *arg3 = 0 ;
20382 bool result;
20383 void *argp1 = 0 ;
20384 int res1 = 0 ;
20385 bool temp2 = false ;
20386 bool temp3 = false ;
20387 PyObject * obj0 = 0 ;
20388 PyObject * obj1 = 0 ;
20389 PyObject * obj2 = 0 ;
20390 char * kwnames[] = {
20391 (char *) "self",(char *) "key",(char *) "value", NULL
20392 };
20393
20394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20396 if (!SWIG_IsOK(res1)) {
20397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20398 }
20399 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20400 {
20401 arg2 = wxString_in_helper(obj1);
20402 if (arg2 == NULL) SWIG_fail;
20403 temp2 = true;
20404 }
20405 {
20406 arg3 = wxString_in_helper(obj2);
20407 if (arg3 == NULL) SWIG_fail;
20408 temp3 = true;
20409 }
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 {
20417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20418 }
20419 {
20420 if (temp2)
20421 delete arg2;
20422 }
20423 {
20424 if (temp3)
20425 delete arg3;
20426 }
20427 return resultobj;
20428 fail:
20429 {
20430 if (temp2)
20431 delete arg2;
20432 }
20433 {
20434 if (temp3)
20435 delete arg3;
20436 }
20437 return NULL;
20438 }
20439
20440
20441 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20442 PyObject *resultobj = 0;
20443 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20444 wxString *arg2 = 0 ;
20445 long arg3 ;
20446 bool result;
20447 void *argp1 = 0 ;
20448 int res1 = 0 ;
20449 bool temp2 = false ;
20450 long val3 ;
20451 int ecode3 = 0 ;
20452 PyObject * obj0 = 0 ;
20453 PyObject * obj1 = 0 ;
20454 PyObject * obj2 = 0 ;
20455 char * kwnames[] = {
20456 (char *) "self",(char *) "key",(char *) "value", NULL
20457 };
20458
20459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20461 if (!SWIG_IsOK(res1)) {
20462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20463 }
20464 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20465 {
20466 arg2 = wxString_in_helper(obj1);
20467 if (arg2 == NULL) SWIG_fail;
20468 temp2 = true;
20469 }
20470 ecode3 = SWIG_AsVal_long(obj2, &val3);
20471 if (!SWIG_IsOK(ecode3)) {
20472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20473 }
20474 arg3 = static_cast< long >(val3);
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 {
20482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20483 }
20484 {
20485 if (temp2)
20486 delete arg2;
20487 }
20488 return resultobj;
20489 fail:
20490 {
20491 if (temp2)
20492 delete arg2;
20493 }
20494 return NULL;
20495 }
20496
20497
20498 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20499 PyObject *resultobj = 0;
20500 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20501 wxString *arg2 = 0 ;
20502 double arg3 ;
20503 bool result;
20504 void *argp1 = 0 ;
20505 int res1 = 0 ;
20506 bool temp2 = false ;
20507 double val3 ;
20508 int ecode3 = 0 ;
20509 PyObject * obj0 = 0 ;
20510 PyObject * obj1 = 0 ;
20511 PyObject * obj2 = 0 ;
20512 char * kwnames[] = {
20513 (char *) "self",(char *) "key",(char *) "value", NULL
20514 };
20515
20516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20518 if (!SWIG_IsOK(res1)) {
20519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20520 }
20521 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20522 {
20523 arg2 = wxString_in_helper(obj1);
20524 if (arg2 == NULL) SWIG_fail;
20525 temp2 = true;
20526 }
20527 ecode3 = SWIG_AsVal_double(obj2, &val3);
20528 if (!SWIG_IsOK(ecode3)) {
20529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20530 }
20531 arg3 = static_cast< double >(val3);
20532 {
20533 PyThreadState* __tstate = wxPyBeginAllowThreads();
20534 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20540 }
20541 {
20542 if (temp2)
20543 delete arg2;
20544 }
20545 return resultobj;
20546 fail:
20547 {
20548 if (temp2)
20549 delete arg2;
20550 }
20551 return NULL;
20552 }
20553
20554
20555 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20556 PyObject *resultobj = 0;
20557 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20558 wxString *arg2 = 0 ;
20559 bool arg3 ;
20560 bool result;
20561 void *argp1 = 0 ;
20562 int res1 = 0 ;
20563 bool temp2 = false ;
20564 bool val3 ;
20565 int ecode3 = 0 ;
20566 PyObject * obj0 = 0 ;
20567 PyObject * obj1 = 0 ;
20568 PyObject * obj2 = 0 ;
20569 char * kwnames[] = {
20570 (char *) "self",(char *) "key",(char *) "value", NULL
20571 };
20572
20573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20575 if (!SWIG_IsOK(res1)) {
20576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20577 }
20578 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20579 {
20580 arg2 = wxString_in_helper(obj1);
20581 if (arg2 == NULL) SWIG_fail;
20582 temp2 = true;
20583 }
20584 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20585 if (!SWIG_IsOK(ecode3)) {
20586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20587 }
20588 arg3 = static_cast< bool >(val3);
20589 {
20590 PyThreadState* __tstate = wxPyBeginAllowThreads();
20591 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 {
20596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20597 }
20598 {
20599 if (temp2)
20600 delete arg2;
20601 }
20602 return resultobj;
20603 fail:
20604 {
20605 if (temp2)
20606 delete arg2;
20607 }
20608 return NULL;
20609 }
20610
20611
20612 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20613 PyObject *resultobj = 0;
20614 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20615 bool arg2 = (bool) false ;
20616 bool result;
20617 void *argp1 = 0 ;
20618 int res1 = 0 ;
20619 bool val2 ;
20620 int ecode2 = 0 ;
20621 PyObject * obj0 = 0 ;
20622 PyObject * obj1 = 0 ;
20623 char * kwnames[] = {
20624 (char *) "self",(char *) "currentOnly", NULL
20625 };
20626
20627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20629 if (!SWIG_IsOK(res1)) {
20630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20631 }
20632 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20633 if (obj1) {
20634 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20635 if (!SWIG_IsOK(ecode2)) {
20636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20637 }
20638 arg2 = static_cast< bool >(val2);
20639 }
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 result = (bool)(arg1)->Flush(arg2);
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 {
20647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20648 }
20649 return resultobj;
20650 fail:
20651 return NULL;
20652 }
20653
20654
20655 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20656 PyObject *resultobj = 0;
20657 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20658 wxString *arg2 = 0 ;
20659 wxString *arg3 = 0 ;
20660 bool result;
20661 void *argp1 = 0 ;
20662 int res1 = 0 ;
20663 bool temp2 = false ;
20664 bool temp3 = false ;
20665 PyObject * obj0 = 0 ;
20666 PyObject * obj1 = 0 ;
20667 PyObject * obj2 = 0 ;
20668 char * kwnames[] = {
20669 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20670 };
20671
20672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20674 if (!SWIG_IsOK(res1)) {
20675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20676 }
20677 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20678 {
20679 arg2 = wxString_in_helper(obj1);
20680 if (arg2 == NULL) SWIG_fail;
20681 temp2 = true;
20682 }
20683 {
20684 arg3 = wxString_in_helper(obj2);
20685 if (arg3 == NULL) SWIG_fail;
20686 temp3 = true;
20687 }
20688 {
20689 PyThreadState* __tstate = wxPyBeginAllowThreads();
20690 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20691 wxPyEndAllowThreads(__tstate);
20692 if (PyErr_Occurred()) SWIG_fail;
20693 }
20694 {
20695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20696 }
20697 {
20698 if (temp2)
20699 delete arg2;
20700 }
20701 {
20702 if (temp3)
20703 delete arg3;
20704 }
20705 return resultobj;
20706 fail:
20707 {
20708 if (temp2)
20709 delete arg2;
20710 }
20711 {
20712 if (temp3)
20713 delete arg3;
20714 }
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj = 0;
20721 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20722 wxString *arg2 = 0 ;
20723 wxString *arg3 = 0 ;
20724 bool result;
20725 void *argp1 = 0 ;
20726 int res1 = 0 ;
20727 bool temp2 = false ;
20728 bool temp3 = false ;
20729 PyObject * obj0 = 0 ;
20730 PyObject * obj1 = 0 ;
20731 PyObject * obj2 = 0 ;
20732 char * kwnames[] = {
20733 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20734 };
20735
20736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20738 if (!SWIG_IsOK(res1)) {
20739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20740 }
20741 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20742 {
20743 arg2 = wxString_in_helper(obj1);
20744 if (arg2 == NULL) SWIG_fail;
20745 temp2 = true;
20746 }
20747 {
20748 arg3 = wxString_in_helper(obj2);
20749 if (arg3 == NULL) SWIG_fail;
20750 temp3 = true;
20751 }
20752 {
20753 PyThreadState* __tstate = wxPyBeginAllowThreads();
20754 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20755 wxPyEndAllowThreads(__tstate);
20756 if (PyErr_Occurred()) SWIG_fail;
20757 }
20758 {
20759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20760 }
20761 {
20762 if (temp2)
20763 delete arg2;
20764 }
20765 {
20766 if (temp3)
20767 delete arg3;
20768 }
20769 return resultobj;
20770 fail:
20771 {
20772 if (temp2)
20773 delete arg2;
20774 }
20775 {
20776 if (temp3)
20777 delete arg3;
20778 }
20779 return NULL;
20780 }
20781
20782
20783 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20784 PyObject *resultobj = 0;
20785 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20786 wxString *arg2 = 0 ;
20787 bool arg3 = (bool) true ;
20788 bool result;
20789 void *argp1 = 0 ;
20790 int res1 = 0 ;
20791 bool temp2 = false ;
20792 bool val3 ;
20793 int ecode3 = 0 ;
20794 PyObject * obj0 = 0 ;
20795 PyObject * obj1 = 0 ;
20796 PyObject * obj2 = 0 ;
20797 char * kwnames[] = {
20798 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20799 };
20800
20801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20803 if (!SWIG_IsOK(res1)) {
20804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20805 }
20806 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20807 {
20808 arg2 = wxString_in_helper(obj1);
20809 if (arg2 == NULL) SWIG_fail;
20810 temp2 = true;
20811 }
20812 if (obj2) {
20813 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20814 if (!SWIG_IsOK(ecode3)) {
20815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20816 }
20817 arg3 = static_cast< bool >(val3);
20818 }
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20822 wxPyEndAllowThreads(__tstate);
20823 if (PyErr_Occurred()) SWIG_fail;
20824 }
20825 {
20826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20827 }
20828 {
20829 if (temp2)
20830 delete arg2;
20831 }
20832 return resultobj;
20833 fail:
20834 {
20835 if (temp2)
20836 delete arg2;
20837 }
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20843 PyObject *resultobj = 0;
20844 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20845 wxString *arg2 = 0 ;
20846 bool result;
20847 void *argp1 = 0 ;
20848 int res1 = 0 ;
20849 bool temp2 = false ;
20850 PyObject * obj0 = 0 ;
20851 PyObject * obj1 = 0 ;
20852 char * kwnames[] = {
20853 (char *) "self",(char *) "key", NULL
20854 };
20855
20856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20858 if (!SWIG_IsOK(res1)) {
20859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20860 }
20861 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20862 {
20863 arg2 = wxString_in_helper(obj1);
20864 if (arg2 == NULL) SWIG_fail;
20865 temp2 = true;
20866 }
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 {
20874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20875 }
20876 {
20877 if (temp2)
20878 delete arg2;
20879 }
20880 return resultobj;
20881 fail:
20882 {
20883 if (temp2)
20884 delete arg2;
20885 }
20886 return NULL;
20887 }
20888
20889
20890 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20891 PyObject *resultobj = 0;
20892 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20893 bool result;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 PyObject *swig_obj[1] ;
20897
20898 if (!args) SWIG_fail;
20899 swig_obj[0] = args;
20900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20901 if (!SWIG_IsOK(res1)) {
20902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20903 }
20904 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 result = (bool)(arg1)->DeleteAll();
20908 wxPyEndAllowThreads(__tstate);
20909 if (PyErr_Occurred()) SWIG_fail;
20910 }
20911 {
20912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20913 }
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20921 PyObject *resultobj = 0;
20922 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20923 bool arg2 = (bool) true ;
20924 void *argp1 = 0 ;
20925 int res1 = 0 ;
20926 bool val2 ;
20927 int ecode2 = 0 ;
20928 PyObject * obj0 = 0 ;
20929 PyObject * obj1 = 0 ;
20930 char * kwnames[] = {
20931 (char *) "self",(char *) "doIt", NULL
20932 };
20933
20934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20936 if (!SWIG_IsOK(res1)) {
20937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20938 }
20939 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20940 if (obj1) {
20941 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20942 if (!SWIG_IsOK(ecode2)) {
20943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20944 }
20945 arg2 = static_cast< bool >(val2);
20946 }
20947 {
20948 PyThreadState* __tstate = wxPyBeginAllowThreads();
20949 (arg1)->SetExpandEnvVars(arg2);
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 resultobj = SWIG_Py_Void();
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20961 PyObject *resultobj = 0;
20962 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20963 bool result;
20964 void *argp1 = 0 ;
20965 int res1 = 0 ;
20966 PyObject *swig_obj[1] ;
20967
20968 if (!args) SWIG_fail;
20969 swig_obj[0] = args;
20970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20971 if (!SWIG_IsOK(res1)) {
20972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20973 }
20974 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20975 {
20976 PyThreadState* __tstate = wxPyBeginAllowThreads();
20977 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20978 wxPyEndAllowThreads(__tstate);
20979 if (PyErr_Occurred()) SWIG_fail;
20980 }
20981 {
20982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20983 }
20984 return resultobj;
20985 fail:
20986 return NULL;
20987 }
20988
20989
20990 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20991 PyObject *resultobj = 0;
20992 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20993 bool arg2 = (bool) true ;
20994 void *argp1 = 0 ;
20995 int res1 = 0 ;
20996 bool val2 ;
20997 int ecode2 = 0 ;
20998 PyObject * obj0 = 0 ;
20999 PyObject * obj1 = 0 ;
21000 char * kwnames[] = {
21001 (char *) "self",(char *) "doIt", NULL
21002 };
21003
21004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21006 if (!SWIG_IsOK(res1)) {
21007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21008 }
21009 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21010 if (obj1) {
21011 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21012 if (!SWIG_IsOK(ecode2)) {
21013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21014 }
21015 arg2 = static_cast< bool >(val2);
21016 }
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 (arg1)->SetRecordDefaults(arg2);
21020 wxPyEndAllowThreads(__tstate);
21021 if (PyErr_Occurred()) SWIG_fail;
21022 }
21023 resultobj = SWIG_Py_Void();
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21031 PyObject *resultobj = 0;
21032 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21033 bool result;
21034 void *argp1 = 0 ;
21035 int res1 = 0 ;
21036 PyObject *swig_obj[1] ;
21037
21038 if (!args) SWIG_fail;
21039 swig_obj[0] = args;
21040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21041 if (!SWIG_IsOK(res1)) {
21042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21043 }
21044 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21048 wxPyEndAllowThreads(__tstate);
21049 if (PyErr_Occurred()) SWIG_fail;
21050 }
21051 {
21052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21053 }
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj = 0;
21062 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21063 wxString *arg2 = 0 ;
21064 wxString result;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 bool temp2 = false ;
21068 PyObject * obj0 = 0 ;
21069 PyObject * obj1 = 0 ;
21070 char * kwnames[] = {
21071 (char *) "self",(char *) "str", NULL
21072 };
21073
21074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21076 if (!SWIG_IsOK(res1)) {
21077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21078 }
21079 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21080 {
21081 arg2 = wxString_in_helper(obj1);
21082 if (arg2 == NULL) SWIG_fail;
21083 temp2 = true;
21084 }
21085 {
21086 PyThreadState* __tstate = wxPyBeginAllowThreads();
21087 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21088 wxPyEndAllowThreads(__tstate);
21089 if (PyErr_Occurred()) SWIG_fail;
21090 }
21091 {
21092 #if wxUSE_UNICODE
21093 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21094 #else
21095 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21096 #endif
21097 }
21098 {
21099 if (temp2)
21100 delete arg2;
21101 }
21102 return resultobj;
21103 fail:
21104 {
21105 if (temp2)
21106 delete arg2;
21107 }
21108 return NULL;
21109 }
21110
21111
21112 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21113 PyObject *resultobj = 0;
21114 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21115 wxString result;
21116 void *argp1 = 0 ;
21117 int res1 = 0 ;
21118 PyObject *swig_obj[1] ;
21119
21120 if (!args) SWIG_fail;
21121 swig_obj[0] = args;
21122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21125 }
21126 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21127 {
21128 PyThreadState* __tstate = wxPyBeginAllowThreads();
21129 result = ((wxConfigBase const *)arg1)->GetAppName();
21130 wxPyEndAllowThreads(__tstate);
21131 if (PyErr_Occurred()) SWIG_fail;
21132 }
21133 {
21134 #if wxUSE_UNICODE
21135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21136 #else
21137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21138 #endif
21139 }
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21147 PyObject *resultobj = 0;
21148 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21149 wxString result;
21150 void *argp1 = 0 ;
21151 int res1 = 0 ;
21152 PyObject *swig_obj[1] ;
21153
21154 if (!args) SWIG_fail;
21155 swig_obj[0] = args;
21156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21157 if (!SWIG_IsOK(res1)) {
21158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21159 }
21160 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21161 {
21162 PyThreadState* __tstate = wxPyBeginAllowThreads();
21163 result = ((wxConfigBase const *)arg1)->GetVendorName();
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 {
21168 #if wxUSE_UNICODE
21169 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21170 #else
21171 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21172 #endif
21173 }
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj = 0;
21182 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21183 wxString *arg2 = 0 ;
21184 void *argp1 = 0 ;
21185 int res1 = 0 ;
21186 bool temp2 = false ;
21187 PyObject * obj0 = 0 ;
21188 PyObject * obj1 = 0 ;
21189 char * kwnames[] = {
21190 (char *) "self",(char *) "appName", NULL
21191 };
21192
21193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21195 if (!SWIG_IsOK(res1)) {
21196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21197 }
21198 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21199 {
21200 arg2 = wxString_in_helper(obj1);
21201 if (arg2 == NULL) SWIG_fail;
21202 temp2 = true;
21203 }
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 (arg1)->SetAppName((wxString const &)*arg2);
21207 wxPyEndAllowThreads(__tstate);
21208 if (PyErr_Occurred()) SWIG_fail;
21209 }
21210 resultobj = SWIG_Py_Void();
21211 {
21212 if (temp2)
21213 delete arg2;
21214 }
21215 return resultobj;
21216 fail:
21217 {
21218 if (temp2)
21219 delete arg2;
21220 }
21221 return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21226 PyObject *resultobj = 0;
21227 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21228 wxString *arg2 = 0 ;
21229 void *argp1 = 0 ;
21230 int res1 = 0 ;
21231 bool temp2 = false ;
21232 PyObject * obj0 = 0 ;
21233 PyObject * obj1 = 0 ;
21234 char * kwnames[] = {
21235 (char *) "self",(char *) "vendorName", NULL
21236 };
21237
21238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21240 if (!SWIG_IsOK(res1)) {
21241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21242 }
21243 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21244 {
21245 arg2 = wxString_in_helper(obj1);
21246 if (arg2 == NULL) SWIG_fail;
21247 temp2 = true;
21248 }
21249 {
21250 PyThreadState* __tstate = wxPyBeginAllowThreads();
21251 (arg1)->SetVendorName((wxString const &)*arg2);
21252 wxPyEndAllowThreads(__tstate);
21253 if (PyErr_Occurred()) SWIG_fail;
21254 }
21255 resultobj = SWIG_Py_Void();
21256 {
21257 if (temp2)
21258 delete arg2;
21259 }
21260 return resultobj;
21261 fail:
21262 {
21263 if (temp2)
21264 delete arg2;
21265 }
21266 return NULL;
21267 }
21268
21269
21270 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21271 PyObject *resultobj = 0;
21272 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21273 long arg2 ;
21274 void *argp1 = 0 ;
21275 int res1 = 0 ;
21276 long val2 ;
21277 int ecode2 = 0 ;
21278 PyObject * obj0 = 0 ;
21279 PyObject * obj1 = 0 ;
21280 char * kwnames[] = {
21281 (char *) "self",(char *) "style", NULL
21282 };
21283
21284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21286 if (!SWIG_IsOK(res1)) {
21287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21288 }
21289 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21290 ecode2 = SWIG_AsVal_long(obj1, &val2);
21291 if (!SWIG_IsOK(ecode2)) {
21292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21293 }
21294 arg2 = static_cast< long >(val2);
21295 {
21296 PyThreadState* __tstate = wxPyBeginAllowThreads();
21297 (arg1)->SetStyle(arg2);
21298 wxPyEndAllowThreads(__tstate);
21299 if (PyErr_Occurred()) SWIG_fail;
21300 }
21301 resultobj = SWIG_Py_Void();
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21309 PyObject *resultobj = 0;
21310 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21311 long result;
21312 void *argp1 = 0 ;
21313 int res1 = 0 ;
21314 PyObject *swig_obj[1] ;
21315
21316 if (!args) SWIG_fail;
21317 swig_obj[0] = args;
21318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21319 if (!SWIG_IsOK(res1)) {
21320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21321 }
21322 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21323 {
21324 PyThreadState* __tstate = wxPyBeginAllowThreads();
21325 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21326 wxPyEndAllowThreads(__tstate);
21327 if (PyErr_Occurred()) SWIG_fail;
21328 }
21329 resultobj = SWIG_From_long(static_cast< long >(result));
21330 return resultobj;
21331 fail:
21332 return NULL;
21333 }
21334
21335
21336 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21337 PyObject *obj;
21338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21339 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21340 return SWIG_Py_Void();
21341 }
21342
21343 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21344 PyObject *resultobj = 0;
21345 wxString const &arg1_defvalue = wxPyEmptyString ;
21346 wxString *arg1 = (wxString *) &arg1_defvalue ;
21347 wxString const &arg2_defvalue = wxPyEmptyString ;
21348 wxString *arg2 = (wxString *) &arg2_defvalue ;
21349 wxString const &arg3_defvalue = wxPyEmptyString ;
21350 wxString *arg3 = (wxString *) &arg3_defvalue ;
21351 wxString const &arg4_defvalue = wxPyEmptyString ;
21352 wxString *arg4 = (wxString *) &arg4_defvalue ;
21353 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21354 wxConfig *result = 0 ;
21355 bool temp1 = false ;
21356 bool temp2 = false ;
21357 bool temp3 = false ;
21358 bool temp4 = false ;
21359 long val5 ;
21360 int ecode5 = 0 ;
21361 PyObject * obj0 = 0 ;
21362 PyObject * obj1 = 0 ;
21363 PyObject * obj2 = 0 ;
21364 PyObject * obj3 = 0 ;
21365 PyObject * obj4 = 0 ;
21366 char * kwnames[] = {
21367 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21368 };
21369
21370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21371 if (obj0) {
21372 {
21373 arg1 = wxString_in_helper(obj0);
21374 if (arg1 == NULL) SWIG_fail;
21375 temp1 = true;
21376 }
21377 }
21378 if (obj1) {
21379 {
21380 arg2 = wxString_in_helper(obj1);
21381 if (arg2 == NULL) SWIG_fail;
21382 temp2 = true;
21383 }
21384 }
21385 if (obj2) {
21386 {
21387 arg3 = wxString_in_helper(obj2);
21388 if (arg3 == NULL) SWIG_fail;
21389 temp3 = true;
21390 }
21391 }
21392 if (obj3) {
21393 {
21394 arg4 = wxString_in_helper(obj3);
21395 if (arg4 == NULL) SWIG_fail;
21396 temp4 = true;
21397 }
21398 }
21399 if (obj4) {
21400 ecode5 = SWIG_AsVal_long(obj4, &val5);
21401 if (!SWIG_IsOK(ecode5)) {
21402 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21403 }
21404 arg5 = static_cast< long >(val5);
21405 }
21406 {
21407 PyThreadState* __tstate = wxPyBeginAllowThreads();
21408 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21409 wxPyEndAllowThreads(__tstate);
21410 if (PyErr_Occurred()) SWIG_fail;
21411 }
21412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21413 {
21414 if (temp1)
21415 delete arg1;
21416 }
21417 {
21418 if (temp2)
21419 delete arg2;
21420 }
21421 {
21422 if (temp3)
21423 delete arg3;
21424 }
21425 {
21426 if (temp4)
21427 delete arg4;
21428 }
21429 return resultobj;
21430 fail:
21431 {
21432 if (temp1)
21433 delete arg1;
21434 }
21435 {
21436 if (temp2)
21437 delete arg2;
21438 }
21439 {
21440 if (temp3)
21441 delete arg3;
21442 }
21443 {
21444 if (temp4)
21445 delete arg4;
21446 }
21447 return NULL;
21448 }
21449
21450
21451 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21452 PyObject *resultobj = 0;
21453 wxConfig *arg1 = (wxConfig *) 0 ;
21454 void *argp1 = 0 ;
21455 int res1 = 0 ;
21456 PyObject *swig_obj[1] ;
21457
21458 if (!args) SWIG_fail;
21459 swig_obj[0] = args;
21460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21461 if (!SWIG_IsOK(res1)) {
21462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21463 }
21464 arg1 = reinterpret_cast< wxConfig * >(argp1);
21465 {
21466 PyThreadState* __tstate = wxPyBeginAllowThreads();
21467 delete arg1;
21468
21469 wxPyEndAllowThreads(__tstate);
21470 if (PyErr_Occurred()) SWIG_fail;
21471 }
21472 resultobj = SWIG_Py_Void();
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21480 PyObject *obj;
21481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21482 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21483 return SWIG_Py_Void();
21484 }
21485
21486 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21487 return SWIG_Python_InitShadowInstance(args);
21488 }
21489
21490 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21491 PyObject *resultobj = 0;
21492 wxString const &arg1_defvalue = wxPyEmptyString ;
21493 wxString *arg1 = (wxString *) &arg1_defvalue ;
21494 wxString const &arg2_defvalue = wxPyEmptyString ;
21495 wxString *arg2 = (wxString *) &arg2_defvalue ;
21496 wxString const &arg3_defvalue = wxPyEmptyString ;
21497 wxString *arg3 = (wxString *) &arg3_defvalue ;
21498 wxString const &arg4_defvalue = wxPyEmptyString ;
21499 wxString *arg4 = (wxString *) &arg4_defvalue ;
21500 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21501 wxFileConfig *result = 0 ;
21502 bool temp1 = false ;
21503 bool temp2 = false ;
21504 bool temp3 = false ;
21505 bool temp4 = false ;
21506 long val5 ;
21507 int ecode5 = 0 ;
21508 PyObject * obj0 = 0 ;
21509 PyObject * obj1 = 0 ;
21510 PyObject * obj2 = 0 ;
21511 PyObject * obj3 = 0 ;
21512 PyObject * obj4 = 0 ;
21513 char * kwnames[] = {
21514 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21515 };
21516
21517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21518 if (obj0) {
21519 {
21520 arg1 = wxString_in_helper(obj0);
21521 if (arg1 == NULL) SWIG_fail;
21522 temp1 = true;
21523 }
21524 }
21525 if (obj1) {
21526 {
21527 arg2 = wxString_in_helper(obj1);
21528 if (arg2 == NULL) SWIG_fail;
21529 temp2 = true;
21530 }
21531 }
21532 if (obj2) {
21533 {
21534 arg3 = wxString_in_helper(obj2);
21535 if (arg3 == NULL) SWIG_fail;
21536 temp3 = true;
21537 }
21538 }
21539 if (obj3) {
21540 {
21541 arg4 = wxString_in_helper(obj3);
21542 if (arg4 == NULL) SWIG_fail;
21543 temp4 = true;
21544 }
21545 }
21546 if (obj4) {
21547 ecode5 = SWIG_AsVal_long(obj4, &val5);
21548 if (!SWIG_IsOK(ecode5)) {
21549 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21550 }
21551 arg5 = static_cast< long >(val5);
21552 }
21553 {
21554 PyThreadState* __tstate = wxPyBeginAllowThreads();
21555 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21556 wxPyEndAllowThreads(__tstate);
21557 if (PyErr_Occurred()) SWIG_fail;
21558 }
21559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21560 {
21561 if (temp1)
21562 delete arg1;
21563 }
21564 {
21565 if (temp2)
21566 delete arg2;
21567 }
21568 {
21569 if (temp3)
21570 delete arg3;
21571 }
21572 {
21573 if (temp4)
21574 delete arg4;
21575 }
21576 return resultobj;
21577 fail:
21578 {
21579 if (temp1)
21580 delete arg1;
21581 }
21582 {
21583 if (temp2)
21584 delete arg2;
21585 }
21586 {
21587 if (temp3)
21588 delete arg3;
21589 }
21590 {
21591 if (temp4)
21592 delete arg4;
21593 }
21594 return NULL;
21595 }
21596
21597
21598 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21599 PyObject *resultobj = 0;
21600 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21601 void *argp1 = 0 ;
21602 int res1 = 0 ;
21603 PyObject *swig_obj[1] ;
21604
21605 if (!args) SWIG_fail;
21606 swig_obj[0] = args;
21607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21608 if (!SWIG_IsOK(res1)) {
21609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21610 }
21611 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21612 {
21613 PyThreadState* __tstate = wxPyBeginAllowThreads();
21614 delete arg1;
21615
21616 wxPyEndAllowThreads(__tstate);
21617 if (PyErr_Occurred()) SWIG_fail;
21618 }
21619 resultobj = SWIG_Py_Void();
21620 return resultobj;
21621 fail:
21622 return NULL;
21623 }
21624
21625
21626 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21627 PyObject *obj;
21628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21629 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21630 return SWIG_Py_Void();
21631 }
21632
21633 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21634 return SWIG_Python_InitShadowInstance(args);
21635 }
21636
21637 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21638 PyObject *resultobj = 0;
21639 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21640 wxString *arg2 = 0 ;
21641 wxConfigPathChanger *result = 0 ;
21642 void *argp1 = 0 ;
21643 int res1 = 0 ;
21644 bool temp2 = false ;
21645 PyObject * obj0 = 0 ;
21646 PyObject * obj1 = 0 ;
21647 char * kwnames[] = {
21648 (char *) "config",(char *) "entry", NULL
21649 };
21650
21651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21653 if (!SWIG_IsOK(res1)) {
21654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21655 }
21656 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21657 {
21658 arg2 = wxString_in_helper(obj1);
21659 if (arg2 == NULL) SWIG_fail;
21660 temp2 = true;
21661 }
21662 {
21663 PyThreadState* __tstate = wxPyBeginAllowThreads();
21664 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21665 wxPyEndAllowThreads(__tstate);
21666 if (PyErr_Occurred()) SWIG_fail;
21667 }
21668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21669 {
21670 if (temp2)
21671 delete arg2;
21672 }
21673 return resultobj;
21674 fail:
21675 {
21676 if (temp2)
21677 delete arg2;
21678 }
21679 return NULL;
21680 }
21681
21682
21683 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21684 PyObject *resultobj = 0;
21685 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21686 void *argp1 = 0 ;
21687 int res1 = 0 ;
21688 PyObject *swig_obj[1] ;
21689
21690 if (!args) SWIG_fail;
21691 swig_obj[0] = args;
21692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21693 if (!SWIG_IsOK(res1)) {
21694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21695 }
21696 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21697 {
21698 PyThreadState* __tstate = wxPyBeginAllowThreads();
21699 delete arg1;
21700
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 resultobj = SWIG_Py_Void();
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21712 PyObject *resultobj = 0;
21713 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21714 wxString *result = 0 ;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 PyObject *swig_obj[1] ;
21718
21719 if (!args) SWIG_fail;
21720 swig_obj[0] = args;
21721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21722 if (!SWIG_IsOK(res1)) {
21723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21724 }
21725 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 {
21729 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21730 result = (wxString *) &_result_ref;
21731 }
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 #if wxUSE_UNICODE
21737 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21738 #else
21739 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21740 #endif
21741 }
21742 return resultobj;
21743 fail:
21744 return NULL;
21745 }
21746
21747
21748 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 PyObject *obj;
21750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21751 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21752 return SWIG_Py_Void();
21753 }
21754
21755 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21756 return SWIG_Python_InitShadowInstance(args);
21757 }
21758
21759 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21760 PyObject *resultobj = 0;
21761 wxString *arg1 = 0 ;
21762 wxString result;
21763 bool temp1 = false ;
21764 PyObject * obj0 = 0 ;
21765 char * kwnames[] = {
21766 (char *) "sz", NULL
21767 };
21768
21769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21770 {
21771 arg1 = wxString_in_helper(obj0);
21772 if (arg1 == NULL) SWIG_fail;
21773 temp1 = true;
21774 }
21775 {
21776 PyThreadState* __tstate = wxPyBeginAllowThreads();
21777 result = wxExpandEnvVars((wxString const &)*arg1);
21778 wxPyEndAllowThreads(__tstate);
21779 if (PyErr_Occurred()) SWIG_fail;
21780 }
21781 {
21782 #if wxUSE_UNICODE
21783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21784 #else
21785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21786 #endif
21787 }
21788 {
21789 if (temp1)
21790 delete arg1;
21791 }
21792 return resultobj;
21793 fail:
21794 {
21795 if (temp1)
21796 delete arg1;
21797 }
21798 return NULL;
21799 }
21800
21801
21802 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21803 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21804 return 1;
21805 }
21806
21807
21808 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21809 PyObject *pyobj = 0;
21810
21811 {
21812 #if wxUSE_UNICODE
21813 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21814 #else
21815 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21816 #endif
21817 }
21818 return pyobj;
21819 }
21820
21821
21822 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21823 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21824 return 1;
21825 }
21826
21827
21828 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21829 PyObject *pyobj = 0;
21830
21831 {
21832 #if wxUSE_UNICODE
21833 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21834 #else
21835 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21836 #endif
21837 }
21838 return pyobj;
21839 }
21840
21841
21842 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21843 PyObject *resultobj = 0;
21844 wxDateTime::Country arg1 ;
21845 int val1 ;
21846 int ecode1 = 0 ;
21847 PyObject * obj0 = 0 ;
21848 char * kwnames[] = {
21849 (char *) "country", NULL
21850 };
21851
21852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21853 ecode1 = SWIG_AsVal_int(obj0, &val1);
21854 if (!SWIG_IsOK(ecode1)) {
21855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21856 }
21857 arg1 = static_cast< wxDateTime::Country >(val1);
21858 {
21859 PyThreadState* __tstate = wxPyBeginAllowThreads();
21860 wxDateTime::SetCountry(arg1);
21861 wxPyEndAllowThreads(__tstate);
21862 if (PyErr_Occurred()) SWIG_fail;
21863 }
21864 resultobj = SWIG_Py_Void();
21865 return resultobj;
21866 fail:
21867 return NULL;
21868 }
21869
21870
21871 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21872 PyObject *resultobj = 0;
21873 wxDateTime::Country result;
21874
21875 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21876 {
21877 PyThreadState* __tstate = wxPyBeginAllowThreads();
21878 result = (wxDateTime::Country)wxDateTime::GetCountry();
21879 wxPyEndAllowThreads(__tstate);
21880 if (PyErr_Occurred()) SWIG_fail;
21881 }
21882 resultobj = SWIG_From_int(static_cast< int >(result));
21883 return resultobj;
21884 fail:
21885 return NULL;
21886 }
21887
21888
21889 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21890 PyObject *resultobj = 0;
21891 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21892 bool result;
21893 int val1 ;
21894 int ecode1 = 0 ;
21895 PyObject * obj0 = 0 ;
21896 char * kwnames[] = {
21897 (char *) "country", NULL
21898 };
21899
21900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21901 if (obj0) {
21902 ecode1 = SWIG_AsVal_int(obj0, &val1);
21903 if (!SWIG_IsOK(ecode1)) {
21904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21905 }
21906 arg1 = static_cast< wxDateTime::Country >(val1);
21907 }
21908 {
21909 PyThreadState* __tstate = wxPyBeginAllowThreads();
21910 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21911 wxPyEndAllowThreads(__tstate);
21912 if (PyErr_Occurred()) SWIG_fail;
21913 }
21914 {
21915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21916 }
21917 return resultobj;
21918 fail:
21919 return NULL;
21920 }
21921
21922
21923 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21924 PyObject *resultobj = 0;
21925 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21926 int result;
21927 int val1 ;
21928 int ecode1 = 0 ;
21929 PyObject * obj0 = 0 ;
21930 char * kwnames[] = {
21931 (char *) "cal", NULL
21932 };
21933
21934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21935 if (obj0) {
21936 ecode1 = SWIG_AsVal_int(obj0, &val1);
21937 if (!SWIG_IsOK(ecode1)) {
21938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21939 }
21940 arg1 = static_cast< wxDateTime::Calendar >(val1);
21941 }
21942 {
21943 PyThreadState* __tstate = wxPyBeginAllowThreads();
21944 result = (int)wxDateTime::GetCurrentYear(arg1);
21945 wxPyEndAllowThreads(__tstate);
21946 if (PyErr_Occurred()) SWIG_fail;
21947 }
21948 resultobj = SWIG_From_int(static_cast< int >(result));
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21956 PyObject *resultobj = 0;
21957 int arg1 ;
21958 int result;
21959 int val1 ;
21960 int ecode1 = 0 ;
21961 PyObject * obj0 = 0 ;
21962 char * kwnames[] = {
21963 (char *) "year", NULL
21964 };
21965
21966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21967 ecode1 = SWIG_AsVal_int(obj0, &val1);
21968 if (!SWIG_IsOK(ecode1)) {
21969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21970 }
21971 arg1 = static_cast< int >(val1);
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 result = (int)wxDateTime::ConvertYearToBC(arg1);
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 resultobj = SWIG_From_int(static_cast< int >(result));
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21986 PyObject *resultobj = 0;
21987 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21988 wxDateTime::Month result;
21989 int val1 ;
21990 int ecode1 = 0 ;
21991 PyObject * obj0 = 0 ;
21992 char * kwnames[] = {
21993 (char *) "cal", NULL
21994 };
21995
21996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21997 if (obj0) {
21998 ecode1 = SWIG_AsVal_int(obj0, &val1);
21999 if (!SWIG_IsOK(ecode1)) {
22000 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22001 }
22002 arg1 = static_cast< wxDateTime::Calendar >(val1);
22003 }
22004 {
22005 PyThreadState* __tstate = wxPyBeginAllowThreads();
22006 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22007 wxPyEndAllowThreads(__tstate);
22008 if (PyErr_Occurred()) SWIG_fail;
22009 }
22010 resultobj = SWIG_From_int(static_cast< int >(result));
22011 return resultobj;
22012 fail:
22013 return NULL;
22014 }
22015
22016
22017 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22018 PyObject *resultobj = 0;
22019 int arg1 = (int) wxDateTime::Inv_Year ;
22020 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22021 bool result;
22022 int val1 ;
22023 int ecode1 = 0 ;
22024 int val2 ;
22025 int ecode2 = 0 ;
22026 PyObject * obj0 = 0 ;
22027 PyObject * obj1 = 0 ;
22028 char * kwnames[] = {
22029 (char *) "year",(char *) "cal", NULL
22030 };
22031
22032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22033 if (obj0) {
22034 ecode1 = SWIG_AsVal_int(obj0, &val1);
22035 if (!SWIG_IsOK(ecode1)) {
22036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22037 }
22038 arg1 = static_cast< int >(val1);
22039 }
22040 if (obj1) {
22041 ecode2 = SWIG_AsVal_int(obj1, &val2);
22042 if (!SWIG_IsOK(ecode2)) {
22043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22044 }
22045 arg2 = static_cast< wxDateTime::Calendar >(val2);
22046 }
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 {
22054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22055 }
22056 return resultobj;
22057 fail:
22058 return NULL;
22059 }
22060
22061
22062 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22063 PyObject *resultobj = 0;
22064 int arg1 = (int) wxDateTime::Inv_Year ;
22065 int result;
22066 int val1 ;
22067 int ecode1 = 0 ;
22068 PyObject * obj0 = 0 ;
22069 char * kwnames[] = {
22070 (char *) "year", NULL
22071 };
22072
22073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22074 if (obj0) {
22075 ecode1 = SWIG_AsVal_int(obj0, &val1);
22076 if (!SWIG_IsOK(ecode1)) {
22077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22078 }
22079 arg1 = static_cast< int >(val1);
22080 }
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (int)wxDateTime::GetCentury(arg1);
22084 wxPyEndAllowThreads(__tstate);
22085 if (PyErr_Occurred()) SWIG_fail;
22086 }
22087 resultobj = SWIG_From_int(static_cast< int >(result));
22088 return resultobj;
22089 fail:
22090 return NULL;
22091 }
22092
22093
22094 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22095 PyObject *resultobj = 0;
22096 int arg1 ;
22097 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22098 int result;
22099 int val1 ;
22100 int ecode1 = 0 ;
22101 int val2 ;
22102 int ecode2 = 0 ;
22103 PyObject * obj0 = 0 ;
22104 PyObject * obj1 = 0 ;
22105 char * kwnames[] = {
22106 (char *) "year",(char *) "cal", NULL
22107 };
22108
22109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22110 ecode1 = SWIG_AsVal_int(obj0, &val1);
22111 if (!SWIG_IsOK(ecode1)) {
22112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22113 }
22114 arg1 = static_cast< int >(val1);
22115 if (obj1) {
22116 ecode2 = SWIG_AsVal_int(obj1, &val2);
22117 if (!SWIG_IsOK(ecode2)) {
22118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22119 }
22120 arg2 = static_cast< wxDateTime::Calendar >(val2);
22121 }
22122 {
22123 PyThreadState* __tstate = wxPyBeginAllowThreads();
22124 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22125 wxPyEndAllowThreads(__tstate);
22126 if (PyErr_Occurred()) SWIG_fail;
22127 }
22128 resultobj = SWIG_From_int(static_cast< int >(result));
22129 return resultobj;
22130 fail:
22131 return NULL;
22132 }
22133
22134
22135 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22136 PyObject *resultobj = 0;
22137 wxDateTime::Month arg1 ;
22138 int arg2 = (int) wxDateTime::Inv_Year ;
22139 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22140 int result;
22141 int val1 ;
22142 int ecode1 = 0 ;
22143 int val2 ;
22144 int ecode2 = 0 ;
22145 int val3 ;
22146 int ecode3 = 0 ;
22147 PyObject * obj0 = 0 ;
22148 PyObject * obj1 = 0 ;
22149 PyObject * obj2 = 0 ;
22150 char * kwnames[] = {
22151 (char *) "month",(char *) "year",(char *) "cal", NULL
22152 };
22153
22154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22155 ecode1 = SWIG_AsVal_int(obj0, &val1);
22156 if (!SWIG_IsOK(ecode1)) {
22157 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22158 }
22159 arg1 = static_cast< wxDateTime::Month >(val1);
22160 if (obj1) {
22161 ecode2 = SWIG_AsVal_int(obj1, &val2);
22162 if (!SWIG_IsOK(ecode2)) {
22163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22164 }
22165 arg2 = static_cast< int >(val2);
22166 }
22167 if (obj2) {
22168 ecode3 = SWIG_AsVal_int(obj2, &val3);
22169 if (!SWIG_IsOK(ecode3)) {
22170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22171 }
22172 arg3 = static_cast< wxDateTime::Calendar >(val3);
22173 }
22174 {
22175 PyThreadState* __tstate = wxPyBeginAllowThreads();
22176 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22177 wxPyEndAllowThreads(__tstate);
22178 if (PyErr_Occurred()) SWIG_fail;
22179 }
22180 resultobj = SWIG_From_int(static_cast< int >(result));
22181 return resultobj;
22182 fail:
22183 return NULL;
22184 }
22185
22186
22187 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22188 PyObject *resultobj = 0;
22189 wxDateTime::Month arg1 ;
22190 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22191 wxString result;
22192 int val1 ;
22193 int ecode1 = 0 ;
22194 int val2 ;
22195 int ecode2 = 0 ;
22196 PyObject * obj0 = 0 ;
22197 PyObject * obj1 = 0 ;
22198 char * kwnames[] = {
22199 (char *) "month",(char *) "flags", NULL
22200 };
22201
22202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22203 ecode1 = SWIG_AsVal_int(obj0, &val1);
22204 if (!SWIG_IsOK(ecode1)) {
22205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22206 }
22207 arg1 = static_cast< wxDateTime::Month >(val1);
22208 if (obj1) {
22209 ecode2 = SWIG_AsVal_int(obj1, &val2);
22210 if (!SWIG_IsOK(ecode2)) {
22211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22212 }
22213 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22214 }
22215 {
22216 PyThreadState* __tstate = wxPyBeginAllowThreads();
22217 result = wxDateTime::GetMonthName(arg1,arg2);
22218 wxPyEndAllowThreads(__tstate);
22219 if (PyErr_Occurred()) SWIG_fail;
22220 }
22221 {
22222 #if wxUSE_UNICODE
22223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22224 #else
22225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22226 #endif
22227 }
22228 return resultobj;
22229 fail:
22230 return NULL;
22231 }
22232
22233
22234 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22235 PyObject *resultobj = 0;
22236 wxDateTime::WeekDay arg1 ;
22237 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22238 wxString result;
22239 int val1 ;
22240 int ecode1 = 0 ;
22241 int val2 ;
22242 int ecode2 = 0 ;
22243 PyObject * obj0 = 0 ;
22244 PyObject * obj1 = 0 ;
22245 char * kwnames[] = {
22246 (char *) "weekday",(char *) "flags", NULL
22247 };
22248
22249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22250 ecode1 = SWIG_AsVal_int(obj0, &val1);
22251 if (!SWIG_IsOK(ecode1)) {
22252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22253 }
22254 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22255 if (obj1) {
22256 ecode2 = SWIG_AsVal_int(obj1, &val2);
22257 if (!SWIG_IsOK(ecode2)) {
22258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22259 }
22260 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22261 }
22262 {
22263 PyThreadState* __tstate = wxPyBeginAllowThreads();
22264 result = wxDateTime::GetWeekDayName(arg1,arg2);
22265 wxPyEndAllowThreads(__tstate);
22266 if (PyErr_Occurred()) SWIG_fail;
22267 }
22268 {
22269 #if wxUSE_UNICODE
22270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22271 #else
22272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22273 #endif
22274 }
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 PyObject *result = 0 ;
22284
22285 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22286 {
22287 PyThreadState* __tstate = wxPyBeginAllowThreads();
22288 result = (PyObject *)wxDateTime_GetAmPmStrings();
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 resultobj = result;
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj = 0;
22301 int arg1 = (int) wxDateTime::Inv_Year ;
22302 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22303 bool result;
22304 int val1 ;
22305 int ecode1 = 0 ;
22306 int val2 ;
22307 int ecode2 = 0 ;
22308 PyObject * obj0 = 0 ;
22309 PyObject * obj1 = 0 ;
22310 char * kwnames[] = {
22311 (char *) "year",(char *) "country", NULL
22312 };
22313
22314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22315 if (obj0) {
22316 ecode1 = SWIG_AsVal_int(obj0, &val1);
22317 if (!SWIG_IsOK(ecode1)) {
22318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22319 }
22320 arg1 = static_cast< int >(val1);
22321 }
22322 if (obj1) {
22323 ecode2 = SWIG_AsVal_int(obj1, &val2);
22324 if (!SWIG_IsOK(ecode2)) {
22325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22326 }
22327 arg2 = static_cast< wxDateTime::Country >(val2);
22328 }
22329 {
22330 PyThreadState* __tstate = wxPyBeginAllowThreads();
22331 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22332 wxPyEndAllowThreads(__tstate);
22333 if (PyErr_Occurred()) SWIG_fail;
22334 }
22335 {
22336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22337 }
22338 return resultobj;
22339 fail:
22340 return NULL;
22341 }
22342
22343
22344 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22345 PyObject *resultobj = 0;
22346 int arg1 = (int) wxDateTime::Inv_Year ;
22347 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22348 wxDateTime result;
22349 int val1 ;
22350 int ecode1 = 0 ;
22351 int val2 ;
22352 int ecode2 = 0 ;
22353 PyObject * obj0 = 0 ;
22354 PyObject * obj1 = 0 ;
22355 char * kwnames[] = {
22356 (char *) "year",(char *) "country", NULL
22357 };
22358
22359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22360 if (obj0) {
22361 ecode1 = SWIG_AsVal_int(obj0, &val1);
22362 if (!SWIG_IsOK(ecode1)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22364 }
22365 arg1 = static_cast< int >(val1);
22366 }
22367 if (obj1) {
22368 ecode2 = SWIG_AsVal_int(obj1, &val2);
22369 if (!SWIG_IsOK(ecode2)) {
22370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22371 }
22372 arg2 = static_cast< wxDateTime::Country >(val2);
22373 }
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 result = wxDateTime::GetBeginDST(arg1,arg2);
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22388 PyObject *resultobj = 0;
22389 int arg1 = (int) wxDateTime::Inv_Year ;
22390 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22391 wxDateTime result;
22392 int val1 ;
22393 int ecode1 = 0 ;
22394 int val2 ;
22395 int ecode2 = 0 ;
22396 PyObject * obj0 = 0 ;
22397 PyObject * obj1 = 0 ;
22398 char * kwnames[] = {
22399 (char *) "year",(char *) "country", NULL
22400 };
22401
22402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22403 if (obj0) {
22404 ecode1 = SWIG_AsVal_int(obj0, &val1);
22405 if (!SWIG_IsOK(ecode1)) {
22406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22407 }
22408 arg1 = static_cast< int >(val1);
22409 }
22410 if (obj1) {
22411 ecode2 = SWIG_AsVal_int(obj1, &val2);
22412 if (!SWIG_IsOK(ecode2)) {
22413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22414 }
22415 arg2 = static_cast< wxDateTime::Country >(val2);
22416 }
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = wxDateTime::GetEndDST(arg1,arg2);
22420 wxPyEndAllowThreads(__tstate);
22421 if (PyErr_Occurred()) SWIG_fail;
22422 }
22423 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22424 return resultobj;
22425 fail:
22426 return NULL;
22427 }
22428
22429
22430 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22431 PyObject *resultobj = 0;
22432 wxDateTime result;
22433
22434 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 result = wxDateTime::Now();
22438 wxPyEndAllowThreads(__tstate);
22439 if (PyErr_Occurred()) SWIG_fail;
22440 }
22441 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22449 PyObject *resultobj = 0;
22450 wxDateTime result;
22451
22452 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22453 {
22454 PyThreadState* __tstate = wxPyBeginAllowThreads();
22455 result = wxDateTime::UNow();
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22467 PyObject *resultobj = 0;
22468 wxDateTime result;
22469
22470 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22471 {
22472 PyThreadState* __tstate = wxPyBeginAllowThreads();
22473 result = wxDateTime::Today();
22474 wxPyEndAllowThreads(__tstate);
22475 if (PyErr_Occurred()) SWIG_fail;
22476 }
22477 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22478 return resultobj;
22479 fail:
22480 return NULL;
22481 }
22482
22483
22484 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22485 PyObject *resultobj = 0;
22486 wxDateTime *result = 0 ;
22487
22488 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 result = (wxDateTime *)new wxDateTime();
22492 wxPyEndAllowThreads(__tstate);
22493 if (PyErr_Occurred()) SWIG_fail;
22494 }
22495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22496 return resultobj;
22497 fail:
22498 return NULL;
22499 }
22500
22501
22502 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22503 PyObject *resultobj = 0;
22504 time_t arg1 ;
22505 wxDateTime *result = 0 ;
22506 unsigned int val1 ;
22507 int ecode1 = 0 ;
22508 PyObject * obj0 = 0 ;
22509 char * kwnames[] = {
22510 (char *) "timet", NULL
22511 };
22512
22513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22514 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22515 if (!SWIG_IsOK(ecode1)) {
22516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22517 }
22518 arg1 = static_cast< time_t >(val1);
22519 {
22520 PyThreadState* __tstate = wxPyBeginAllowThreads();
22521 result = (wxDateTime *)new wxDateTime(arg1);
22522 wxPyEndAllowThreads(__tstate);
22523 if (PyErr_Occurred()) SWIG_fail;
22524 }
22525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22526 return resultobj;
22527 fail:
22528 return NULL;
22529 }
22530
22531
22532 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22533 PyObject *resultobj = 0;
22534 double arg1 ;
22535 wxDateTime *result = 0 ;
22536 double val1 ;
22537 int ecode1 = 0 ;
22538 PyObject * obj0 = 0 ;
22539 char * kwnames[] = {
22540 (char *) "jdn", NULL
22541 };
22542
22543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22544 ecode1 = SWIG_AsVal_double(obj0, &val1);
22545 if (!SWIG_IsOK(ecode1)) {
22546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22547 }
22548 arg1 = static_cast< double >(val1);
22549 {
22550 PyThreadState* __tstate = wxPyBeginAllowThreads();
22551 result = (wxDateTime *)new wxDateTime(arg1);
22552 wxPyEndAllowThreads(__tstate);
22553 if (PyErr_Occurred()) SWIG_fail;
22554 }
22555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22556 return resultobj;
22557 fail:
22558 return NULL;
22559 }
22560
22561
22562 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22563 PyObject *resultobj = 0;
22564 int arg1 ;
22565 int arg2 = (int) 0 ;
22566 int arg3 = (int) 0 ;
22567 int arg4 = (int) 0 ;
22568 wxDateTime *result = 0 ;
22569 int val1 ;
22570 int ecode1 = 0 ;
22571 int val2 ;
22572 int ecode2 = 0 ;
22573 int val3 ;
22574 int ecode3 = 0 ;
22575 int val4 ;
22576 int ecode4 = 0 ;
22577 PyObject * obj0 = 0 ;
22578 PyObject * obj1 = 0 ;
22579 PyObject * obj2 = 0 ;
22580 PyObject * obj3 = 0 ;
22581 char * kwnames[] = {
22582 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22583 };
22584
22585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22586 ecode1 = SWIG_AsVal_int(obj0, &val1);
22587 if (!SWIG_IsOK(ecode1)) {
22588 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22589 }
22590 arg1 = static_cast< int >(val1);
22591 if (obj1) {
22592 ecode2 = SWIG_AsVal_int(obj1, &val2);
22593 if (!SWIG_IsOK(ecode2)) {
22594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22595 }
22596 arg2 = static_cast< int >(val2);
22597 }
22598 if (obj2) {
22599 ecode3 = SWIG_AsVal_int(obj2, &val3);
22600 if (!SWIG_IsOK(ecode3)) {
22601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22602 }
22603 arg3 = static_cast< int >(val3);
22604 }
22605 if (obj3) {
22606 ecode4 = SWIG_AsVal_int(obj3, &val4);
22607 if (!SWIG_IsOK(ecode4)) {
22608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22609 }
22610 arg4 = static_cast< int >(val4);
22611 }
22612 {
22613 PyThreadState* __tstate = wxPyBeginAllowThreads();
22614 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22615 wxPyEndAllowThreads(__tstate);
22616 if (PyErr_Occurred()) SWIG_fail;
22617 }
22618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22626 PyObject *resultobj = 0;
22627 int arg1 ;
22628 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22629 int arg3 = (int) wxDateTime::Inv_Year ;
22630 int arg4 = (int) 0 ;
22631 int arg5 = (int) 0 ;
22632 int arg6 = (int) 0 ;
22633 int arg7 = (int) 0 ;
22634 wxDateTime *result = 0 ;
22635 int val1 ;
22636 int ecode1 = 0 ;
22637 int val2 ;
22638 int ecode2 = 0 ;
22639 int val3 ;
22640 int ecode3 = 0 ;
22641 int val4 ;
22642 int ecode4 = 0 ;
22643 int val5 ;
22644 int ecode5 = 0 ;
22645 int val6 ;
22646 int ecode6 = 0 ;
22647 int val7 ;
22648 int ecode7 = 0 ;
22649 PyObject * obj0 = 0 ;
22650 PyObject * obj1 = 0 ;
22651 PyObject * obj2 = 0 ;
22652 PyObject * obj3 = 0 ;
22653 PyObject * obj4 = 0 ;
22654 PyObject * obj5 = 0 ;
22655 PyObject * obj6 = 0 ;
22656 char * kwnames[] = {
22657 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22658 };
22659
22660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22661 ecode1 = SWIG_AsVal_int(obj0, &val1);
22662 if (!SWIG_IsOK(ecode1)) {
22663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22664 }
22665 arg1 = static_cast< int >(val1);
22666 if (obj1) {
22667 ecode2 = SWIG_AsVal_int(obj1, &val2);
22668 if (!SWIG_IsOK(ecode2)) {
22669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22670 }
22671 arg2 = static_cast< wxDateTime::Month >(val2);
22672 }
22673 if (obj2) {
22674 ecode3 = SWIG_AsVal_int(obj2, &val3);
22675 if (!SWIG_IsOK(ecode3)) {
22676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22677 }
22678 arg3 = static_cast< int >(val3);
22679 }
22680 if (obj3) {
22681 ecode4 = SWIG_AsVal_int(obj3, &val4);
22682 if (!SWIG_IsOK(ecode4)) {
22683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22684 }
22685 arg4 = static_cast< int >(val4);
22686 }
22687 if (obj4) {
22688 ecode5 = SWIG_AsVal_int(obj4, &val5);
22689 if (!SWIG_IsOK(ecode5)) {
22690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22691 }
22692 arg5 = static_cast< int >(val5);
22693 }
22694 if (obj5) {
22695 ecode6 = SWIG_AsVal_int(obj5, &val6);
22696 if (!SWIG_IsOK(ecode6)) {
22697 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22698 }
22699 arg6 = static_cast< int >(val6);
22700 }
22701 if (obj6) {
22702 ecode7 = SWIG_AsVal_int(obj6, &val7);
22703 if (!SWIG_IsOK(ecode7)) {
22704 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22705 }
22706 arg7 = static_cast< int >(val7);
22707 }
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22711 wxPyEndAllowThreads(__tstate);
22712 if (PyErr_Occurred()) SWIG_fail;
22713 }
22714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22715 return resultobj;
22716 fail:
22717 return NULL;
22718 }
22719
22720
22721 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22722 PyObject *resultobj = 0;
22723 wxDateTime *arg1 = 0 ;
22724 wxDateTime *result = 0 ;
22725 void *argp1 = 0 ;
22726 int res1 = 0 ;
22727 PyObject * obj0 = 0 ;
22728 char * kwnames[] = {
22729 (char *) "date", NULL
22730 };
22731
22732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22733 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22734 if (!SWIG_IsOK(res1)) {
22735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22736 }
22737 if (!argp1) {
22738 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22739 }
22740 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22741 {
22742 PyThreadState* __tstate = wxPyBeginAllowThreads();
22743 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22744 wxPyEndAllowThreads(__tstate);
22745 if (PyErr_Occurred()) SWIG_fail;
22746 }
22747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22748 return resultobj;
22749 fail:
22750 return NULL;
22751 }
22752
22753
22754 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22755 PyObject *resultobj = 0;
22756 wxDateTime *arg1 = (wxDateTime *) 0 ;
22757 void *argp1 = 0 ;
22758 int res1 = 0 ;
22759 PyObject *swig_obj[1] ;
22760
22761 if (!args) SWIG_fail;
22762 swig_obj[0] = args;
22763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22764 if (!SWIG_IsOK(res1)) {
22765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22766 }
22767 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22768 {
22769 PyThreadState* __tstate = wxPyBeginAllowThreads();
22770 delete arg1;
22771
22772 wxPyEndAllowThreads(__tstate);
22773 if (PyErr_Occurred()) SWIG_fail;
22774 }
22775 resultobj = SWIG_Py_Void();
22776 return resultobj;
22777 fail:
22778 return NULL;
22779 }
22780
22781
22782 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22783 PyObject *resultobj = 0;
22784 wxDateTime *arg1 = (wxDateTime *) 0 ;
22785 wxDateTime *result = 0 ;
22786 void *argp1 = 0 ;
22787 int res1 = 0 ;
22788 PyObject *swig_obj[1] ;
22789
22790 if (!args) SWIG_fail;
22791 swig_obj[0] = args;
22792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22793 if (!SWIG_IsOK(res1)) {
22794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22795 }
22796 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 {
22800 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22801 result = (wxDateTime *) &_result_ref;
22802 }
22803 wxPyEndAllowThreads(__tstate);
22804 if (PyErr_Occurred()) SWIG_fail;
22805 }
22806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22807 return resultobj;
22808 fail:
22809 return NULL;
22810 }
22811
22812
22813 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22814 PyObject *resultobj = 0;
22815 wxDateTime *arg1 = (wxDateTime *) 0 ;
22816 time_t arg2 ;
22817 wxDateTime *result = 0 ;
22818 void *argp1 = 0 ;
22819 int res1 = 0 ;
22820 unsigned int val2 ;
22821 int ecode2 = 0 ;
22822 PyObject * obj0 = 0 ;
22823 PyObject * obj1 = 0 ;
22824 char * kwnames[] = {
22825 (char *) "self",(char *) "timet", NULL
22826 };
22827
22828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22830 if (!SWIG_IsOK(res1)) {
22831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22832 }
22833 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22834 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22835 if (!SWIG_IsOK(ecode2)) {
22836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22837 }
22838 arg2 = static_cast< time_t >(val2);
22839 {
22840 PyThreadState* __tstate = wxPyBeginAllowThreads();
22841 {
22842 wxDateTime &_result_ref = (arg1)->Set(arg2);
22843 result = (wxDateTime *) &_result_ref;
22844 }
22845 wxPyEndAllowThreads(__tstate);
22846 if (PyErr_Occurred()) SWIG_fail;
22847 }
22848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22849 return resultobj;
22850 fail:
22851 return NULL;
22852 }
22853
22854
22855 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22856 PyObject *resultobj = 0;
22857 wxDateTime *arg1 = (wxDateTime *) 0 ;
22858 double arg2 ;
22859 wxDateTime *result = 0 ;
22860 void *argp1 = 0 ;
22861 int res1 = 0 ;
22862 double val2 ;
22863 int ecode2 = 0 ;
22864 PyObject * obj0 = 0 ;
22865 PyObject * obj1 = 0 ;
22866 char * kwnames[] = {
22867 (char *) "self",(char *) "jdn", NULL
22868 };
22869
22870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22872 if (!SWIG_IsOK(res1)) {
22873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22874 }
22875 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22876 ecode2 = SWIG_AsVal_double(obj1, &val2);
22877 if (!SWIG_IsOK(ecode2)) {
22878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22879 }
22880 arg2 = static_cast< double >(val2);
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 {
22884 wxDateTime &_result_ref = (arg1)->Set(arg2);
22885 result = (wxDateTime *) &_result_ref;
22886 }
22887 wxPyEndAllowThreads(__tstate);
22888 if (PyErr_Occurred()) SWIG_fail;
22889 }
22890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22898 PyObject *resultobj = 0;
22899 wxDateTime *arg1 = (wxDateTime *) 0 ;
22900 int arg2 ;
22901 int arg3 = (int) 0 ;
22902 int arg4 = (int) 0 ;
22903 int arg5 = (int) 0 ;
22904 wxDateTime *result = 0 ;
22905 void *argp1 = 0 ;
22906 int res1 = 0 ;
22907 int val2 ;
22908 int ecode2 = 0 ;
22909 int val3 ;
22910 int ecode3 = 0 ;
22911 int val4 ;
22912 int ecode4 = 0 ;
22913 int val5 ;
22914 int ecode5 = 0 ;
22915 PyObject * obj0 = 0 ;
22916 PyObject * obj1 = 0 ;
22917 PyObject * obj2 = 0 ;
22918 PyObject * obj3 = 0 ;
22919 PyObject * obj4 = 0 ;
22920 char * kwnames[] = {
22921 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22922 };
22923
22924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22926 if (!SWIG_IsOK(res1)) {
22927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22928 }
22929 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22930 ecode2 = SWIG_AsVal_int(obj1, &val2);
22931 if (!SWIG_IsOK(ecode2)) {
22932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22933 }
22934 arg2 = static_cast< int >(val2);
22935 if (obj2) {
22936 ecode3 = SWIG_AsVal_int(obj2, &val3);
22937 if (!SWIG_IsOK(ecode3)) {
22938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22939 }
22940 arg3 = static_cast< int >(val3);
22941 }
22942 if (obj3) {
22943 ecode4 = SWIG_AsVal_int(obj3, &val4);
22944 if (!SWIG_IsOK(ecode4)) {
22945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22946 }
22947 arg4 = static_cast< int >(val4);
22948 }
22949 if (obj4) {
22950 ecode5 = SWIG_AsVal_int(obj4, &val5);
22951 if (!SWIG_IsOK(ecode5)) {
22952 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22953 }
22954 arg5 = static_cast< int >(val5);
22955 }
22956 {
22957 PyThreadState* __tstate = wxPyBeginAllowThreads();
22958 {
22959 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22960 result = (wxDateTime *) &_result_ref;
22961 }
22962 wxPyEndAllowThreads(__tstate);
22963 if (PyErr_Occurred()) SWIG_fail;
22964 }
22965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22966 return resultobj;
22967 fail:
22968 return NULL;
22969 }
22970
22971
22972 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22973 PyObject *resultobj = 0;
22974 wxDateTime *arg1 = (wxDateTime *) 0 ;
22975 int arg2 ;
22976 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22977 int arg4 = (int) wxDateTime::Inv_Year ;
22978 int arg5 = (int) 0 ;
22979 int arg6 = (int) 0 ;
22980 int arg7 = (int) 0 ;
22981 int arg8 = (int) 0 ;
22982 wxDateTime *result = 0 ;
22983 void *argp1 = 0 ;
22984 int res1 = 0 ;
22985 int val2 ;
22986 int ecode2 = 0 ;
22987 int val3 ;
22988 int ecode3 = 0 ;
22989 int val4 ;
22990 int ecode4 = 0 ;
22991 int val5 ;
22992 int ecode5 = 0 ;
22993 int val6 ;
22994 int ecode6 = 0 ;
22995 int val7 ;
22996 int ecode7 = 0 ;
22997 int val8 ;
22998 int ecode8 = 0 ;
22999 PyObject * obj0 = 0 ;
23000 PyObject * obj1 = 0 ;
23001 PyObject * obj2 = 0 ;
23002 PyObject * obj3 = 0 ;
23003 PyObject * obj4 = 0 ;
23004 PyObject * obj5 = 0 ;
23005 PyObject * obj6 = 0 ;
23006 PyObject * obj7 = 0 ;
23007 char * kwnames[] = {
23008 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23009 };
23010
23011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23013 if (!SWIG_IsOK(res1)) {
23014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23015 }
23016 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23017 ecode2 = SWIG_AsVal_int(obj1, &val2);
23018 if (!SWIG_IsOK(ecode2)) {
23019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23020 }
23021 arg2 = static_cast< int >(val2);
23022 if (obj2) {
23023 ecode3 = SWIG_AsVal_int(obj2, &val3);
23024 if (!SWIG_IsOK(ecode3)) {
23025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23026 }
23027 arg3 = static_cast< wxDateTime::Month >(val3);
23028 }
23029 if (obj3) {
23030 ecode4 = SWIG_AsVal_int(obj3, &val4);
23031 if (!SWIG_IsOK(ecode4)) {
23032 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23033 }
23034 arg4 = static_cast< int >(val4);
23035 }
23036 if (obj4) {
23037 ecode5 = SWIG_AsVal_int(obj4, &val5);
23038 if (!SWIG_IsOK(ecode5)) {
23039 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23040 }
23041 arg5 = static_cast< int >(val5);
23042 }
23043 if (obj5) {
23044 ecode6 = SWIG_AsVal_int(obj5, &val6);
23045 if (!SWIG_IsOK(ecode6)) {
23046 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23047 }
23048 arg6 = static_cast< int >(val6);
23049 }
23050 if (obj6) {
23051 ecode7 = SWIG_AsVal_int(obj6, &val7);
23052 if (!SWIG_IsOK(ecode7)) {
23053 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23054 }
23055 arg7 = static_cast< int >(val7);
23056 }
23057 if (obj7) {
23058 ecode8 = SWIG_AsVal_int(obj7, &val8);
23059 if (!SWIG_IsOK(ecode8)) {
23060 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23061 }
23062 arg8 = static_cast< int >(val8);
23063 }
23064 {
23065 PyThreadState* __tstate = wxPyBeginAllowThreads();
23066 {
23067 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23068 result = (wxDateTime *) &_result_ref;
23069 }
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 PyObject *resultobj = 0;
23082 wxDateTime *arg1 = (wxDateTime *) 0 ;
23083 wxDateTime *result = 0 ;
23084 void *argp1 = 0 ;
23085 int res1 = 0 ;
23086 PyObject *swig_obj[1] ;
23087
23088 if (!args) SWIG_fail;
23089 swig_obj[0] = args;
23090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23091 if (!SWIG_IsOK(res1)) {
23092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23093 }
23094 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 {
23098 wxDateTime &_result_ref = (arg1)->ResetTime();
23099 result = (wxDateTime *) &_result_ref;
23100 }
23101 wxPyEndAllowThreads(__tstate);
23102 if (PyErr_Occurred()) SWIG_fail;
23103 }
23104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23112 PyObject *resultobj = 0;
23113 wxDateTime *arg1 = (wxDateTime *) 0 ;
23114 int arg2 ;
23115 wxDateTime *result = 0 ;
23116 void *argp1 = 0 ;
23117 int res1 = 0 ;
23118 int val2 ;
23119 int ecode2 = 0 ;
23120 PyObject * obj0 = 0 ;
23121 PyObject * obj1 = 0 ;
23122 char * kwnames[] = {
23123 (char *) "self",(char *) "year", NULL
23124 };
23125
23126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23128 if (!SWIG_IsOK(res1)) {
23129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23130 }
23131 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23132 ecode2 = SWIG_AsVal_int(obj1, &val2);
23133 if (!SWIG_IsOK(ecode2)) {
23134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23135 }
23136 arg2 = static_cast< int >(val2);
23137 {
23138 PyThreadState* __tstate = wxPyBeginAllowThreads();
23139 {
23140 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23141 result = (wxDateTime *) &_result_ref;
23142 }
23143 wxPyEndAllowThreads(__tstate);
23144 if (PyErr_Occurred()) SWIG_fail;
23145 }
23146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23147 return resultobj;
23148 fail:
23149 return NULL;
23150 }
23151
23152
23153 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23154 PyObject *resultobj = 0;
23155 wxDateTime *arg1 = (wxDateTime *) 0 ;
23156 wxDateTime::Month arg2 ;
23157 wxDateTime *result = 0 ;
23158 void *argp1 = 0 ;
23159 int res1 = 0 ;
23160 int val2 ;
23161 int ecode2 = 0 ;
23162 PyObject * obj0 = 0 ;
23163 PyObject * obj1 = 0 ;
23164 char * kwnames[] = {
23165 (char *) "self",(char *) "month", NULL
23166 };
23167
23168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23170 if (!SWIG_IsOK(res1)) {
23171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23172 }
23173 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23174 ecode2 = SWIG_AsVal_int(obj1, &val2);
23175 if (!SWIG_IsOK(ecode2)) {
23176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23177 }
23178 arg2 = static_cast< wxDateTime::Month >(val2);
23179 {
23180 PyThreadState* __tstate = wxPyBeginAllowThreads();
23181 {
23182 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23183 result = (wxDateTime *) &_result_ref;
23184 }
23185 wxPyEndAllowThreads(__tstate);
23186 if (PyErr_Occurred()) SWIG_fail;
23187 }
23188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23189 return resultobj;
23190 fail:
23191 return NULL;
23192 }
23193
23194
23195 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23196 PyObject *resultobj = 0;
23197 wxDateTime *arg1 = (wxDateTime *) 0 ;
23198 int arg2 ;
23199 wxDateTime *result = 0 ;
23200 void *argp1 = 0 ;
23201 int res1 = 0 ;
23202 int val2 ;
23203 int ecode2 = 0 ;
23204 PyObject * obj0 = 0 ;
23205 PyObject * obj1 = 0 ;
23206 char * kwnames[] = {
23207 (char *) "self",(char *) "day", NULL
23208 };
23209
23210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23212 if (!SWIG_IsOK(res1)) {
23213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23214 }
23215 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23216 ecode2 = SWIG_AsVal_int(obj1, &val2);
23217 if (!SWIG_IsOK(ecode2)) {
23218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23219 }
23220 arg2 = static_cast< int >(val2);
23221 {
23222 PyThreadState* __tstate = wxPyBeginAllowThreads();
23223 {
23224 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23225 result = (wxDateTime *) &_result_ref;
23226 }
23227 wxPyEndAllowThreads(__tstate);
23228 if (PyErr_Occurred()) SWIG_fail;
23229 }
23230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23231 return resultobj;
23232 fail:
23233 return NULL;
23234 }
23235
23236
23237 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj = 0;
23239 wxDateTime *arg1 = (wxDateTime *) 0 ;
23240 int arg2 ;
23241 wxDateTime *result = 0 ;
23242 void *argp1 = 0 ;
23243 int res1 = 0 ;
23244 int val2 ;
23245 int ecode2 = 0 ;
23246 PyObject * obj0 = 0 ;
23247 PyObject * obj1 = 0 ;
23248 char * kwnames[] = {
23249 (char *) "self",(char *) "hour", NULL
23250 };
23251
23252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23254 if (!SWIG_IsOK(res1)) {
23255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23256 }
23257 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23258 ecode2 = SWIG_AsVal_int(obj1, &val2);
23259 if (!SWIG_IsOK(ecode2)) {
23260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23261 }
23262 arg2 = static_cast< int >(val2);
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 {
23266 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23267 result = (wxDateTime *) &_result_ref;
23268 }
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj = 0;
23281 wxDateTime *arg1 = (wxDateTime *) 0 ;
23282 int arg2 ;
23283 wxDateTime *result = 0 ;
23284 void *argp1 = 0 ;
23285 int res1 = 0 ;
23286 int val2 ;
23287 int ecode2 = 0 ;
23288 PyObject * obj0 = 0 ;
23289 PyObject * obj1 = 0 ;
23290 char * kwnames[] = {
23291 (char *) "self",(char *) "minute", NULL
23292 };
23293
23294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23296 if (!SWIG_IsOK(res1)) {
23297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23298 }
23299 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23300 ecode2 = SWIG_AsVal_int(obj1, &val2);
23301 if (!SWIG_IsOK(ecode2)) {
23302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23303 }
23304 arg2 = static_cast< int >(val2);
23305 {
23306 PyThreadState* __tstate = wxPyBeginAllowThreads();
23307 {
23308 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23309 result = (wxDateTime *) &_result_ref;
23310 }
23311 wxPyEndAllowThreads(__tstate);
23312 if (PyErr_Occurred()) SWIG_fail;
23313 }
23314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23315 return resultobj;
23316 fail:
23317 return NULL;
23318 }
23319
23320
23321 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23322 PyObject *resultobj = 0;
23323 wxDateTime *arg1 = (wxDateTime *) 0 ;
23324 int arg2 ;
23325 wxDateTime *result = 0 ;
23326 void *argp1 = 0 ;
23327 int res1 = 0 ;
23328 int val2 ;
23329 int ecode2 = 0 ;
23330 PyObject * obj0 = 0 ;
23331 PyObject * obj1 = 0 ;
23332 char * kwnames[] = {
23333 (char *) "self",(char *) "second", NULL
23334 };
23335
23336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23338 if (!SWIG_IsOK(res1)) {
23339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23340 }
23341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23342 ecode2 = SWIG_AsVal_int(obj1, &val2);
23343 if (!SWIG_IsOK(ecode2)) {
23344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23345 }
23346 arg2 = static_cast< int >(val2);
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 {
23350 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23351 result = (wxDateTime *) &_result_ref;
23352 }
23353 wxPyEndAllowThreads(__tstate);
23354 if (PyErr_Occurred()) SWIG_fail;
23355 }
23356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23357 return resultobj;
23358 fail:
23359 return NULL;
23360 }
23361
23362
23363 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23364 PyObject *resultobj = 0;
23365 wxDateTime *arg1 = (wxDateTime *) 0 ;
23366 int arg2 ;
23367 wxDateTime *result = 0 ;
23368 void *argp1 = 0 ;
23369 int res1 = 0 ;
23370 int val2 ;
23371 int ecode2 = 0 ;
23372 PyObject * obj0 = 0 ;
23373 PyObject * obj1 = 0 ;
23374 char * kwnames[] = {
23375 (char *) "self",(char *) "millisecond", NULL
23376 };
23377
23378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23380 if (!SWIG_IsOK(res1)) {
23381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23382 }
23383 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23384 ecode2 = SWIG_AsVal_int(obj1, &val2);
23385 if (!SWIG_IsOK(ecode2)) {
23386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23387 }
23388 arg2 = static_cast< int >(val2);
23389 {
23390 PyThreadState* __tstate = wxPyBeginAllowThreads();
23391 {
23392 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23393 result = (wxDateTime *) &_result_ref;
23394 }
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj = 0;
23407 wxDateTime *arg1 = (wxDateTime *) 0 ;
23408 wxDateTime::WeekDay arg2 ;
23409 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23410 wxDateTime *result = 0 ;
23411 void *argp1 = 0 ;
23412 int res1 = 0 ;
23413 int val2 ;
23414 int ecode2 = 0 ;
23415 int val3 ;
23416 int ecode3 = 0 ;
23417 PyObject * obj0 = 0 ;
23418 PyObject * obj1 = 0 ;
23419 PyObject * obj2 = 0 ;
23420 char * kwnames[] = {
23421 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23422 };
23423
23424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23426 if (!SWIG_IsOK(res1)) {
23427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23428 }
23429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23430 ecode2 = SWIG_AsVal_int(obj1, &val2);
23431 if (!SWIG_IsOK(ecode2)) {
23432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23433 }
23434 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23435 if (obj2) {
23436 ecode3 = SWIG_AsVal_int(obj2, &val3);
23437 if (!SWIG_IsOK(ecode3)) {
23438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23439 }
23440 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23441 }
23442 {
23443 PyThreadState* __tstate = wxPyBeginAllowThreads();
23444 {
23445 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23446 result = (wxDateTime *) &_result_ref;
23447 }
23448 wxPyEndAllowThreads(__tstate);
23449 if (PyErr_Occurred()) SWIG_fail;
23450 }
23451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23452 return resultobj;
23453 fail:
23454 return NULL;
23455 }
23456
23457
23458 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23459 PyObject *resultobj = 0;
23460 wxDateTime *arg1 = (wxDateTime *) 0 ;
23461 wxDateTime::WeekDay arg2 ;
23462 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23463 wxDateTime result;
23464 void *argp1 = 0 ;
23465 int res1 = 0 ;
23466 int val2 ;
23467 int ecode2 = 0 ;
23468 int val3 ;
23469 int ecode3 = 0 ;
23470 PyObject * obj0 = 0 ;
23471 PyObject * obj1 = 0 ;
23472 PyObject * obj2 = 0 ;
23473 char * kwnames[] = {
23474 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23475 };
23476
23477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23479 if (!SWIG_IsOK(res1)) {
23480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23481 }
23482 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23483 ecode2 = SWIG_AsVal_int(obj1, &val2);
23484 if (!SWIG_IsOK(ecode2)) {
23485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23486 }
23487 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23488 if (obj2) {
23489 ecode3 = SWIG_AsVal_int(obj2, &val3);
23490 if (!SWIG_IsOK(ecode3)) {
23491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23492 }
23493 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23494 }
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23509 PyObject *resultobj = 0;
23510 wxDateTime *arg1 = (wxDateTime *) 0 ;
23511 wxDateTime::WeekDay arg2 ;
23512 wxDateTime *result = 0 ;
23513 void *argp1 = 0 ;
23514 int res1 = 0 ;
23515 int val2 ;
23516 int ecode2 = 0 ;
23517 PyObject * obj0 = 0 ;
23518 PyObject * obj1 = 0 ;
23519 char * kwnames[] = {
23520 (char *) "self",(char *) "weekday", NULL
23521 };
23522
23523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23525 if (!SWIG_IsOK(res1)) {
23526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23527 }
23528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23529 ecode2 = SWIG_AsVal_int(obj1, &val2);
23530 if (!SWIG_IsOK(ecode2)) {
23531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23532 }
23533 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 {
23537 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23538 result = (wxDateTime *) &_result_ref;
23539 }
23540 wxPyEndAllowThreads(__tstate);
23541 if (PyErr_Occurred()) SWIG_fail;
23542 }
23543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23544 return resultobj;
23545 fail:
23546 return NULL;
23547 }
23548
23549
23550 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23551 PyObject *resultobj = 0;
23552 wxDateTime *arg1 = (wxDateTime *) 0 ;
23553 wxDateTime::WeekDay arg2 ;
23554 wxDateTime result;
23555 void *argp1 = 0 ;
23556 int res1 = 0 ;
23557 int val2 ;
23558 int ecode2 = 0 ;
23559 PyObject * obj0 = 0 ;
23560 PyObject * obj1 = 0 ;
23561 char * kwnames[] = {
23562 (char *) "self",(char *) "weekday", NULL
23563 };
23564
23565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23567 if (!SWIG_IsOK(res1)) {
23568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23569 }
23570 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23571 ecode2 = SWIG_AsVal_int(obj1, &val2);
23572 if (!SWIG_IsOK(ecode2)) {
23573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23574 }
23575 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (arg1)->GetNextWeekDay(arg2);
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23590 PyObject *resultobj = 0;
23591 wxDateTime *arg1 = (wxDateTime *) 0 ;
23592 wxDateTime::WeekDay arg2 ;
23593 wxDateTime *result = 0 ;
23594 void *argp1 = 0 ;
23595 int res1 = 0 ;
23596 int val2 ;
23597 int ecode2 = 0 ;
23598 PyObject * obj0 = 0 ;
23599 PyObject * obj1 = 0 ;
23600 char * kwnames[] = {
23601 (char *) "self",(char *) "weekday", NULL
23602 };
23603
23604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) 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_SetToPrevWeekDay" "', 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_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23613 }
23614 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 {
23618 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23619 result = (wxDateTime *) &_result_ref;
23620 }
23621 wxPyEndAllowThreads(__tstate);
23622 if (PyErr_Occurred()) SWIG_fail;
23623 }
23624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj = 0;
23633 wxDateTime *arg1 = (wxDateTime *) 0 ;
23634 wxDateTime::WeekDay arg2 ;
23635 wxDateTime result;
23636 void *argp1 = 0 ;
23637 int res1 = 0 ;
23638 int val2 ;
23639 int ecode2 = 0 ;
23640 PyObject * obj0 = 0 ;
23641 PyObject * obj1 = 0 ;
23642 char * kwnames[] = {
23643 (char *) "self",(char *) "weekday", NULL
23644 };
23645
23646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23648 if (!SWIG_IsOK(res1)) {
23649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23650 }
23651 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23652 ecode2 = SWIG_AsVal_int(obj1, &val2);
23653 if (!SWIG_IsOK(ecode2)) {
23654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23655 }
23656 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23657 {
23658 PyThreadState* __tstate = wxPyBeginAllowThreads();
23659 result = (arg1)->GetPrevWeekDay(arg2);
23660 wxPyEndAllowThreads(__tstate);
23661 if (PyErr_Occurred()) SWIG_fail;
23662 }
23663 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23664 return resultobj;
23665 fail:
23666 return NULL;
23667 }
23668
23669
23670 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23671 PyObject *resultobj = 0;
23672 wxDateTime *arg1 = (wxDateTime *) 0 ;
23673 wxDateTime::WeekDay arg2 ;
23674 int arg3 = (int) 1 ;
23675 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23676 int arg5 = (int) wxDateTime::Inv_Year ;
23677 bool result;
23678 void *argp1 = 0 ;
23679 int res1 = 0 ;
23680 int val2 ;
23681 int ecode2 = 0 ;
23682 int val3 ;
23683 int ecode3 = 0 ;
23684 int val4 ;
23685 int ecode4 = 0 ;
23686 int val5 ;
23687 int ecode5 = 0 ;
23688 PyObject * obj0 = 0 ;
23689 PyObject * obj1 = 0 ;
23690 PyObject * obj2 = 0 ;
23691 PyObject * obj3 = 0 ;
23692 PyObject * obj4 = 0 ;
23693 char * kwnames[] = {
23694 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23695 };
23696
23697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23699 if (!SWIG_IsOK(res1)) {
23700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23701 }
23702 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23703 ecode2 = SWIG_AsVal_int(obj1, &val2);
23704 if (!SWIG_IsOK(ecode2)) {
23705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23706 }
23707 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23708 if (obj2) {
23709 ecode3 = SWIG_AsVal_int(obj2, &val3);
23710 if (!SWIG_IsOK(ecode3)) {
23711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23712 }
23713 arg3 = static_cast< int >(val3);
23714 }
23715 if (obj3) {
23716 ecode4 = SWIG_AsVal_int(obj3, &val4);
23717 if (!SWIG_IsOK(ecode4)) {
23718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23719 }
23720 arg4 = static_cast< wxDateTime::Month >(val4);
23721 }
23722 if (obj4) {
23723 ecode5 = SWIG_AsVal_int(obj4, &val5);
23724 if (!SWIG_IsOK(ecode5)) {
23725 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23726 }
23727 arg5 = static_cast< int >(val5);
23728 }
23729 {
23730 PyThreadState* __tstate = wxPyBeginAllowThreads();
23731 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23732 wxPyEndAllowThreads(__tstate);
23733 if (PyErr_Occurred()) SWIG_fail;
23734 }
23735 {
23736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23737 }
23738 return resultobj;
23739 fail:
23740 return NULL;
23741 }
23742
23743
23744 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23745 PyObject *resultobj = 0;
23746 wxDateTime *arg1 = (wxDateTime *) 0 ;
23747 wxDateTime::WeekDay arg2 ;
23748 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23749 int arg4 = (int) wxDateTime::Inv_Year ;
23750 bool result;
23751 void *argp1 = 0 ;
23752 int res1 = 0 ;
23753 int val2 ;
23754 int ecode2 = 0 ;
23755 int val3 ;
23756 int ecode3 = 0 ;
23757 int val4 ;
23758 int ecode4 = 0 ;
23759 PyObject * obj0 = 0 ;
23760 PyObject * obj1 = 0 ;
23761 PyObject * obj2 = 0 ;
23762 PyObject * obj3 = 0 ;
23763 char * kwnames[] = {
23764 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23765 };
23766
23767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23769 if (!SWIG_IsOK(res1)) {
23770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23771 }
23772 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23773 ecode2 = SWIG_AsVal_int(obj1, &val2);
23774 if (!SWIG_IsOK(ecode2)) {
23775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23776 }
23777 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23778 if (obj2) {
23779 ecode3 = SWIG_AsVal_int(obj2, &val3);
23780 if (!SWIG_IsOK(ecode3)) {
23781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23782 }
23783 arg3 = static_cast< wxDateTime::Month >(val3);
23784 }
23785 if (obj3) {
23786 ecode4 = SWIG_AsVal_int(obj3, &val4);
23787 if (!SWIG_IsOK(ecode4)) {
23788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23789 }
23790 arg4 = static_cast< int >(val4);
23791 }
23792 {
23793 PyThreadState* __tstate = wxPyBeginAllowThreads();
23794 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23795 wxPyEndAllowThreads(__tstate);
23796 if (PyErr_Occurred()) SWIG_fail;
23797 }
23798 {
23799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23800 }
23801 return resultobj;
23802 fail:
23803 return NULL;
23804 }
23805
23806
23807 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23808 PyObject *resultobj = 0;
23809 wxDateTime *arg1 = (wxDateTime *) 0 ;
23810 wxDateTime::WeekDay arg2 ;
23811 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23812 int arg4 = (int) wxDateTime::Inv_Year ;
23813 wxDateTime result;
23814 void *argp1 = 0 ;
23815 int res1 = 0 ;
23816 int val2 ;
23817 int ecode2 = 0 ;
23818 int val3 ;
23819 int ecode3 = 0 ;
23820 int val4 ;
23821 int ecode4 = 0 ;
23822 PyObject * obj0 = 0 ;
23823 PyObject * obj1 = 0 ;
23824 PyObject * obj2 = 0 ;
23825 PyObject * obj3 = 0 ;
23826 char * kwnames[] = {
23827 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23828 };
23829
23830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23832 if (!SWIG_IsOK(res1)) {
23833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23834 }
23835 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23836 ecode2 = SWIG_AsVal_int(obj1, &val2);
23837 if (!SWIG_IsOK(ecode2)) {
23838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23839 }
23840 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23841 if (obj2) {
23842 ecode3 = SWIG_AsVal_int(obj2, &val3);
23843 if (!SWIG_IsOK(ecode3)) {
23844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23845 }
23846 arg3 = static_cast< wxDateTime::Month >(val3);
23847 }
23848 if (obj3) {
23849 ecode4 = SWIG_AsVal_int(obj3, &val4);
23850 if (!SWIG_IsOK(ecode4)) {
23851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23852 }
23853 arg4 = static_cast< int >(val4);
23854 }
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23869 PyObject *resultobj = 0;
23870 wxDateTime *arg1 = (wxDateTime *) 0 ;
23871 int arg2 ;
23872 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23873 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23874 bool result;
23875 void *argp1 = 0 ;
23876 int res1 = 0 ;
23877 int val2 ;
23878 int ecode2 = 0 ;
23879 int val3 ;
23880 int ecode3 = 0 ;
23881 int val4 ;
23882 int ecode4 = 0 ;
23883 PyObject * obj0 = 0 ;
23884 PyObject * obj1 = 0 ;
23885 PyObject * obj2 = 0 ;
23886 PyObject * obj3 = 0 ;
23887 char * kwnames[] = {
23888 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23889 };
23890
23891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23893 if (!SWIG_IsOK(res1)) {
23894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23895 }
23896 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23897 ecode2 = SWIG_AsVal_int(obj1, &val2);
23898 if (!SWIG_IsOK(ecode2)) {
23899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23900 }
23901 arg2 = static_cast< int >(val2);
23902 if (obj2) {
23903 ecode3 = SWIG_AsVal_int(obj2, &val3);
23904 if (!SWIG_IsOK(ecode3)) {
23905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23906 }
23907 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23908 }
23909 if (obj3) {
23910 ecode4 = SWIG_AsVal_int(obj3, &val4);
23911 if (!SWIG_IsOK(ecode4)) {
23912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23913 }
23914 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23915 }
23916 {
23917 PyThreadState* __tstate = wxPyBeginAllowThreads();
23918 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 {
23923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23924 }
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23932 PyObject *resultobj = 0;
23933 wxDateTime *arg1 = (wxDateTime *) 0 ;
23934 int arg2 ;
23935 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23936 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23937 wxDateTime result;
23938 void *argp1 = 0 ;
23939 int res1 = 0 ;
23940 int val2 ;
23941 int ecode2 = 0 ;
23942 int val3 ;
23943 int ecode3 = 0 ;
23944 int val4 ;
23945 int ecode4 = 0 ;
23946 PyObject * obj0 = 0 ;
23947 PyObject * obj1 = 0 ;
23948 PyObject * obj2 = 0 ;
23949 PyObject * obj3 = 0 ;
23950 char * kwnames[] = {
23951 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23952 };
23953
23954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23956 if (!SWIG_IsOK(res1)) {
23957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23958 }
23959 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23960 ecode2 = SWIG_AsVal_int(obj1, &val2);
23961 if (!SWIG_IsOK(ecode2)) {
23962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23963 }
23964 arg2 = static_cast< int >(val2);
23965 if (obj2) {
23966 ecode3 = SWIG_AsVal_int(obj2, &val3);
23967 if (!SWIG_IsOK(ecode3)) {
23968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23969 }
23970 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23971 }
23972 if (obj3) {
23973 ecode4 = SWIG_AsVal_int(obj3, &val4);
23974 if (!SWIG_IsOK(ecode4)) {
23975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23976 }
23977 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23978 }
23979 {
23980 PyThreadState* __tstate = wxPyBeginAllowThreads();
23981 result = (arg1)->GetWeek(arg2,arg3,arg4);
23982 wxPyEndAllowThreads(__tstate);
23983 if (PyErr_Occurred()) SWIG_fail;
23984 }
23985 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23986 return resultobj;
23987 fail:
23988 return NULL;
23989 }
23990
23991
23992 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23993 PyObject *resultobj = 0;
23994 int arg1 ;
23995 int arg2 ;
23996 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23997 wxDateTime result;
23998 int val1 ;
23999 int ecode1 = 0 ;
24000 int val2 ;
24001 int ecode2 = 0 ;
24002 int val3 ;
24003 int ecode3 = 0 ;
24004 PyObject * obj0 = 0 ;
24005 PyObject * obj1 = 0 ;
24006 PyObject * obj2 = 0 ;
24007 char * kwnames[] = {
24008 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24009 };
24010
24011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24012 ecode1 = SWIG_AsVal_int(obj0, &val1);
24013 if (!SWIG_IsOK(ecode1)) {
24014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24015 }
24016 arg1 = static_cast< int >(val1);
24017 ecode2 = SWIG_AsVal_int(obj1, &val2);
24018 if (!SWIG_IsOK(ecode2)) {
24019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24020 }
24021 arg2 = static_cast< int >(val2);
24022 if (obj2) {
24023 ecode3 = SWIG_AsVal_int(obj2, &val3);
24024 if (!SWIG_IsOK(ecode3)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24026 }
24027 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24028 }
24029 {
24030 PyThreadState* __tstate = wxPyBeginAllowThreads();
24031 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24032 wxPyEndAllowThreads(__tstate);
24033 if (PyErr_Occurred()) SWIG_fail;
24034 }
24035 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24036 return resultobj;
24037 fail:
24038 return NULL;
24039 }
24040
24041
24042 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24043 PyObject *resultobj = 0;
24044 wxDateTime *arg1 = (wxDateTime *) 0 ;
24045 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24046 int arg3 = (int) wxDateTime::Inv_Year ;
24047 wxDateTime *result = 0 ;
24048 void *argp1 = 0 ;
24049 int res1 = 0 ;
24050 int val2 ;
24051 int ecode2 = 0 ;
24052 int val3 ;
24053 int ecode3 = 0 ;
24054 PyObject * obj0 = 0 ;
24055 PyObject * obj1 = 0 ;
24056 PyObject * obj2 = 0 ;
24057 char * kwnames[] = {
24058 (char *) "self",(char *) "month",(char *) "year", NULL
24059 };
24060
24061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24063 if (!SWIG_IsOK(res1)) {
24064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24065 }
24066 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24067 if (obj1) {
24068 ecode2 = SWIG_AsVal_int(obj1, &val2);
24069 if (!SWIG_IsOK(ecode2)) {
24070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24071 }
24072 arg2 = static_cast< wxDateTime::Month >(val2);
24073 }
24074 if (obj2) {
24075 ecode3 = SWIG_AsVal_int(obj2, &val3);
24076 if (!SWIG_IsOK(ecode3)) {
24077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24078 }
24079 arg3 = static_cast< int >(val3);
24080 }
24081 {
24082 PyThreadState* __tstate = wxPyBeginAllowThreads();
24083 {
24084 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24085 result = (wxDateTime *) &_result_ref;
24086 }
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj = 0;
24099 wxDateTime *arg1 = (wxDateTime *) 0 ;
24100 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24101 int arg3 = (int) wxDateTime::Inv_Year ;
24102 wxDateTime result;
24103 void *argp1 = 0 ;
24104 int res1 = 0 ;
24105 int val2 ;
24106 int ecode2 = 0 ;
24107 int val3 ;
24108 int ecode3 = 0 ;
24109 PyObject * obj0 = 0 ;
24110 PyObject * obj1 = 0 ;
24111 PyObject * obj2 = 0 ;
24112 char * kwnames[] = {
24113 (char *) "self",(char *) "month",(char *) "year", NULL
24114 };
24115
24116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24118 if (!SWIG_IsOK(res1)) {
24119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24120 }
24121 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24122 if (obj1) {
24123 ecode2 = SWIG_AsVal_int(obj1, &val2);
24124 if (!SWIG_IsOK(ecode2)) {
24125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24126 }
24127 arg2 = static_cast< wxDateTime::Month >(val2);
24128 }
24129 if (obj2) {
24130 ecode3 = SWIG_AsVal_int(obj2, &val3);
24131 if (!SWIG_IsOK(ecode3)) {
24132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24133 }
24134 arg3 = static_cast< int >(val3);
24135 }
24136 {
24137 PyThreadState* __tstate = wxPyBeginAllowThreads();
24138 result = (arg1)->GetLastMonthDay(arg2,arg3);
24139 wxPyEndAllowThreads(__tstate);
24140 if (PyErr_Occurred()) SWIG_fail;
24141 }
24142 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24143 return resultobj;
24144 fail:
24145 return NULL;
24146 }
24147
24148
24149 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24150 PyObject *resultobj = 0;
24151 wxDateTime *arg1 = (wxDateTime *) 0 ;
24152 int arg2 ;
24153 wxDateTime *result = 0 ;
24154 void *argp1 = 0 ;
24155 int res1 = 0 ;
24156 int val2 ;
24157 int ecode2 = 0 ;
24158 PyObject * obj0 = 0 ;
24159 PyObject * obj1 = 0 ;
24160 char * kwnames[] = {
24161 (char *) "self",(char *) "yday", NULL
24162 };
24163
24164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24166 if (!SWIG_IsOK(res1)) {
24167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24168 }
24169 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24170 ecode2 = SWIG_AsVal_int(obj1, &val2);
24171 if (!SWIG_IsOK(ecode2)) {
24172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24173 }
24174 arg2 = static_cast< int >(val2);
24175 {
24176 PyThreadState* __tstate = wxPyBeginAllowThreads();
24177 {
24178 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24179 result = (wxDateTime *) &_result_ref;
24180 }
24181 wxPyEndAllowThreads(__tstate);
24182 if (PyErr_Occurred()) SWIG_fail;
24183 }
24184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24185 return resultobj;
24186 fail:
24187 return NULL;
24188 }
24189
24190
24191 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24192 PyObject *resultobj = 0;
24193 wxDateTime *arg1 = (wxDateTime *) 0 ;
24194 int arg2 ;
24195 wxDateTime result;
24196 void *argp1 = 0 ;
24197 int res1 = 0 ;
24198 int val2 ;
24199 int ecode2 = 0 ;
24200 PyObject * obj0 = 0 ;
24201 PyObject * obj1 = 0 ;
24202 char * kwnames[] = {
24203 (char *) "self",(char *) "yday", NULL
24204 };
24205
24206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24208 if (!SWIG_IsOK(res1)) {
24209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24210 }
24211 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24212 ecode2 = SWIG_AsVal_int(obj1, &val2);
24213 if (!SWIG_IsOK(ecode2)) {
24214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24215 }
24216 arg2 = static_cast< int >(val2);
24217 {
24218 PyThreadState* __tstate = wxPyBeginAllowThreads();
24219 result = (arg1)->GetYearDay(arg2);
24220 wxPyEndAllowThreads(__tstate);
24221 if (PyErr_Occurred()) SWIG_fail;
24222 }
24223 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24231 PyObject *resultobj = 0;
24232 wxDateTime *arg1 = (wxDateTime *) 0 ;
24233 double result;
24234 void *argp1 = 0 ;
24235 int res1 = 0 ;
24236 PyObject *swig_obj[1] ;
24237
24238 if (!args) SWIG_fail;
24239 swig_obj[0] = args;
24240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24241 if (!SWIG_IsOK(res1)) {
24242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24243 }
24244 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24245 {
24246 PyThreadState* __tstate = wxPyBeginAllowThreads();
24247 result = (double)(arg1)->GetJulianDayNumber();
24248 wxPyEndAllowThreads(__tstate);
24249 if (PyErr_Occurred()) SWIG_fail;
24250 }
24251 resultobj = SWIG_From_double(static_cast< double >(result));
24252 return resultobj;
24253 fail:
24254 return NULL;
24255 }
24256
24257
24258 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24259 PyObject *resultobj = 0;
24260 wxDateTime *arg1 = (wxDateTime *) 0 ;
24261 double result;
24262 void *argp1 = 0 ;
24263 int res1 = 0 ;
24264 PyObject *swig_obj[1] ;
24265
24266 if (!args) SWIG_fail;
24267 swig_obj[0] = args;
24268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24269 if (!SWIG_IsOK(res1)) {
24270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24271 }
24272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24273 {
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 result = (double)(arg1)->GetJDN();
24276 wxPyEndAllowThreads(__tstate);
24277 if (PyErr_Occurred()) SWIG_fail;
24278 }
24279 resultobj = SWIG_From_double(static_cast< double >(result));
24280 return resultobj;
24281 fail:
24282 return NULL;
24283 }
24284
24285
24286 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24287 PyObject *resultobj = 0;
24288 wxDateTime *arg1 = (wxDateTime *) 0 ;
24289 double result;
24290 void *argp1 = 0 ;
24291 int res1 = 0 ;
24292 PyObject *swig_obj[1] ;
24293
24294 if (!args) SWIG_fail;
24295 swig_obj[0] = args;
24296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24297 if (!SWIG_IsOK(res1)) {
24298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24299 }
24300 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24301 {
24302 PyThreadState* __tstate = wxPyBeginAllowThreads();
24303 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24304 wxPyEndAllowThreads(__tstate);
24305 if (PyErr_Occurred()) SWIG_fail;
24306 }
24307 resultobj = SWIG_From_double(static_cast< double >(result));
24308 return resultobj;
24309 fail:
24310 return NULL;
24311 }
24312
24313
24314 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24315 PyObject *resultobj = 0;
24316 wxDateTime *arg1 = (wxDateTime *) 0 ;
24317 double result;
24318 void *argp1 = 0 ;
24319 int res1 = 0 ;
24320 PyObject *swig_obj[1] ;
24321
24322 if (!args) SWIG_fail;
24323 swig_obj[0] = args;
24324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24325 if (!SWIG_IsOK(res1)) {
24326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24327 }
24328 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24329 {
24330 PyThreadState* __tstate = wxPyBeginAllowThreads();
24331 result = (double)(arg1)->GetMJD();
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 resultobj = SWIG_From_double(static_cast< double >(result));
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24343 PyObject *resultobj = 0;
24344 wxDateTime *arg1 = (wxDateTime *) 0 ;
24345 double result;
24346 void *argp1 = 0 ;
24347 int res1 = 0 ;
24348 PyObject *swig_obj[1] ;
24349
24350 if (!args) SWIG_fail;
24351 swig_obj[0] = args;
24352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24353 if (!SWIG_IsOK(res1)) {
24354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24355 }
24356 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24357 {
24358 PyThreadState* __tstate = wxPyBeginAllowThreads();
24359 result = (double)(arg1)->GetRataDie();
24360 wxPyEndAllowThreads(__tstate);
24361 if (PyErr_Occurred()) SWIG_fail;
24362 }
24363 resultobj = SWIG_From_double(static_cast< double >(result));
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24371 PyObject *resultobj = 0;
24372 wxDateTime *arg1 = (wxDateTime *) 0 ;
24373 wxDateTime::TimeZone *arg2 = 0 ;
24374 bool arg3 = (bool) false ;
24375 wxDateTime result;
24376 void *argp1 = 0 ;
24377 int res1 = 0 ;
24378 bool temp2 = false ;
24379 bool val3 ;
24380 int ecode3 = 0 ;
24381 PyObject * obj0 = 0 ;
24382 PyObject * obj1 = 0 ;
24383 PyObject * obj2 = 0 ;
24384 char * kwnames[] = {
24385 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24386 };
24387
24388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24390 if (!SWIG_IsOK(res1)) {
24391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24392 }
24393 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24394 {
24395 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24396 temp2 = true;
24397 }
24398 if (obj2) {
24399 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24400 if (!SWIG_IsOK(ecode3)) {
24401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24402 }
24403 arg3 = static_cast< bool >(val3);
24404 }
24405 {
24406 PyThreadState* __tstate = wxPyBeginAllowThreads();
24407 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24408 wxPyEndAllowThreads(__tstate);
24409 if (PyErr_Occurred()) SWIG_fail;
24410 }
24411 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24412 {
24413 if (temp2) delete arg2;
24414 }
24415 return resultobj;
24416 fail:
24417 {
24418 if (temp2) delete arg2;
24419 }
24420 return NULL;
24421 }
24422
24423
24424 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24425 PyObject *resultobj = 0;
24426 wxDateTime *arg1 = (wxDateTime *) 0 ;
24427 wxDateTime::TimeZone *arg2 = 0 ;
24428 bool arg3 = (bool) false ;
24429 wxDateTime *result = 0 ;
24430 void *argp1 = 0 ;
24431 int res1 = 0 ;
24432 bool temp2 = false ;
24433 bool val3 ;
24434 int ecode3 = 0 ;
24435 PyObject * obj0 = 0 ;
24436 PyObject * obj1 = 0 ;
24437 PyObject * obj2 = 0 ;
24438 char * kwnames[] = {
24439 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24440 };
24441
24442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24444 if (!SWIG_IsOK(res1)) {
24445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24446 }
24447 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24448 {
24449 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24450 temp2 = true;
24451 }
24452 if (obj2) {
24453 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24454 if (!SWIG_IsOK(ecode3)) {
24455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24456 }
24457 arg3 = static_cast< bool >(val3);
24458 }
24459 {
24460 PyThreadState* __tstate = wxPyBeginAllowThreads();
24461 {
24462 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24463 result = (wxDateTime *) &_result_ref;
24464 }
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24469 {
24470 if (temp2) delete arg2;
24471 }
24472 return resultobj;
24473 fail:
24474 {
24475 if (temp2) delete arg2;
24476 }
24477 return NULL;
24478 }
24479
24480
24481 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj = 0;
24483 wxDateTime *arg1 = (wxDateTime *) 0 ;
24484 wxDateTime::TimeZone *arg2 = 0 ;
24485 bool arg3 = (bool) false ;
24486 wxDateTime result;
24487 void *argp1 = 0 ;
24488 int res1 = 0 ;
24489 bool temp2 = false ;
24490 bool val3 ;
24491 int ecode3 = 0 ;
24492 PyObject * obj0 = 0 ;
24493 PyObject * obj1 = 0 ;
24494 PyObject * obj2 = 0 ;
24495 char * kwnames[] = {
24496 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24497 };
24498
24499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24501 if (!SWIG_IsOK(res1)) {
24502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24503 }
24504 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24505 {
24506 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24507 temp2 = true;
24508 }
24509 if (obj2) {
24510 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24511 if (!SWIG_IsOK(ecode3)) {
24512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24513 }
24514 arg3 = static_cast< bool >(val3);
24515 }
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24519 wxPyEndAllowThreads(__tstate);
24520 if (PyErr_Occurred()) SWIG_fail;
24521 }
24522 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24523 {
24524 if (temp2) delete arg2;
24525 }
24526 return resultobj;
24527 fail:
24528 {
24529 if (temp2) delete arg2;
24530 }
24531 return NULL;
24532 }
24533
24534
24535 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24536 PyObject *resultobj = 0;
24537 wxDateTime *arg1 = (wxDateTime *) 0 ;
24538 wxDateTime::TimeZone *arg2 = 0 ;
24539 bool arg3 = (bool) false ;
24540 wxDateTime *result = 0 ;
24541 void *argp1 = 0 ;
24542 int res1 = 0 ;
24543 bool temp2 = false ;
24544 bool val3 ;
24545 int ecode3 = 0 ;
24546 PyObject * obj0 = 0 ;
24547 PyObject * obj1 = 0 ;
24548 PyObject * obj2 = 0 ;
24549 char * kwnames[] = {
24550 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24551 };
24552
24553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24555 if (!SWIG_IsOK(res1)) {
24556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24557 }
24558 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24559 {
24560 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24561 temp2 = true;
24562 }
24563 if (obj2) {
24564 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24565 if (!SWIG_IsOK(ecode3)) {
24566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24567 }
24568 arg3 = static_cast< bool >(val3);
24569 }
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 {
24573 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24574 result = (wxDateTime *) &_result_ref;
24575 }
24576 wxPyEndAllowThreads(__tstate);
24577 if (PyErr_Occurred()) SWIG_fail;
24578 }
24579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24580 {
24581 if (temp2) delete arg2;
24582 }
24583 return resultobj;
24584 fail:
24585 {
24586 if (temp2) delete arg2;
24587 }
24588 return NULL;
24589 }
24590
24591
24592 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24593 PyObject *resultobj = 0;
24594 wxDateTime *arg1 = (wxDateTime *) 0 ;
24595 bool arg2 = (bool) false ;
24596 wxDateTime result;
24597 void *argp1 = 0 ;
24598 int res1 = 0 ;
24599 bool val2 ;
24600 int ecode2 = 0 ;
24601 PyObject * obj0 = 0 ;
24602 PyObject * obj1 = 0 ;
24603 char * kwnames[] = {
24604 (char *) "self",(char *) "noDST", NULL
24605 };
24606
24607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24611 }
24612 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24613 if (obj1) {
24614 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24615 if (!SWIG_IsOK(ecode2)) {
24616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24617 }
24618 arg2 = static_cast< bool >(val2);
24619 }
24620 {
24621 PyThreadState* __tstate = wxPyBeginAllowThreads();
24622 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24623 wxPyEndAllowThreads(__tstate);
24624 if (PyErr_Occurred()) SWIG_fail;
24625 }
24626 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24627 return resultobj;
24628 fail:
24629 return NULL;
24630 }
24631
24632
24633 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24634 PyObject *resultobj = 0;
24635 wxDateTime *arg1 = (wxDateTime *) 0 ;
24636 bool arg2 = (bool) false ;
24637 wxDateTime *result = 0 ;
24638 void *argp1 = 0 ;
24639 int res1 = 0 ;
24640 bool val2 ;
24641 int ecode2 = 0 ;
24642 PyObject * obj0 = 0 ;
24643 PyObject * obj1 = 0 ;
24644 char * kwnames[] = {
24645 (char *) "self",(char *) "noDST", NULL
24646 };
24647
24648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24650 if (!SWIG_IsOK(res1)) {
24651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24652 }
24653 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24654 if (obj1) {
24655 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24656 if (!SWIG_IsOK(ecode2)) {
24657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24658 }
24659 arg2 = static_cast< bool >(val2);
24660 }
24661 {
24662 PyThreadState* __tstate = wxPyBeginAllowThreads();
24663 {
24664 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24665 result = (wxDateTime *) &_result_ref;
24666 }
24667 wxPyEndAllowThreads(__tstate);
24668 if (PyErr_Occurred()) SWIG_fail;
24669 }
24670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24671 return resultobj;
24672 fail:
24673 return NULL;
24674 }
24675
24676
24677 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24678 PyObject *resultobj = 0;
24679 wxDateTime *arg1 = (wxDateTime *) 0 ;
24680 bool arg2 = (bool) false ;
24681 wxDateTime result;
24682 void *argp1 = 0 ;
24683 int res1 = 0 ;
24684 bool val2 ;
24685 int ecode2 = 0 ;
24686 PyObject * obj0 = 0 ;
24687 PyObject * obj1 = 0 ;
24688 char * kwnames[] = {
24689 (char *) "self",(char *) "noDST", NULL
24690 };
24691
24692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24694 if (!SWIG_IsOK(res1)) {
24695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24696 }
24697 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24698 if (obj1) {
24699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24700 if (!SWIG_IsOK(ecode2)) {
24701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24702 }
24703 arg2 = static_cast< bool >(val2);
24704 }
24705 {
24706 PyThreadState* __tstate = wxPyBeginAllowThreads();
24707 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24708 wxPyEndAllowThreads(__tstate);
24709 if (PyErr_Occurred()) SWIG_fail;
24710 }
24711 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24712 return resultobj;
24713 fail:
24714 return NULL;
24715 }
24716
24717
24718 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24719 PyObject *resultobj = 0;
24720 wxDateTime *arg1 = (wxDateTime *) 0 ;
24721 bool arg2 = (bool) false ;
24722 wxDateTime *result = 0 ;
24723 void *argp1 = 0 ;
24724 int res1 = 0 ;
24725 bool val2 ;
24726 int ecode2 = 0 ;
24727 PyObject * obj0 = 0 ;
24728 PyObject * obj1 = 0 ;
24729 char * kwnames[] = {
24730 (char *) "self",(char *) "noDST", NULL
24731 };
24732
24733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24735 if (!SWIG_IsOK(res1)) {
24736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24737 }
24738 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24739 if (obj1) {
24740 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24741 if (!SWIG_IsOK(ecode2)) {
24742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24743 }
24744 arg2 = static_cast< bool >(val2);
24745 }
24746 {
24747 PyThreadState* __tstate = wxPyBeginAllowThreads();
24748 {
24749 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24750 result = (wxDateTime *) &_result_ref;
24751 }
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24756 return resultobj;
24757 fail:
24758 return NULL;
24759 }
24760
24761
24762 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24763 PyObject *resultobj = 0;
24764 wxDateTime *arg1 = (wxDateTime *) 0 ;
24765 bool arg2 = (bool) false ;
24766 wxDateTime result;
24767 void *argp1 = 0 ;
24768 int res1 = 0 ;
24769 bool val2 ;
24770 int ecode2 = 0 ;
24771 PyObject * obj0 = 0 ;
24772 PyObject * obj1 = 0 ;
24773 char * kwnames[] = {
24774 (char *) "self",(char *) "noDST", NULL
24775 };
24776
24777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24779 if (!SWIG_IsOK(res1)) {
24780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24781 }
24782 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24783 if (obj1) {
24784 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24785 if (!SWIG_IsOK(ecode2)) {
24786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24787 }
24788 arg2 = static_cast< bool >(val2);
24789 }
24790 {
24791 PyThreadState* __tstate = wxPyBeginAllowThreads();
24792 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24793 wxPyEndAllowThreads(__tstate);
24794 if (PyErr_Occurred()) SWIG_fail;
24795 }
24796 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj = 0;
24805 wxDateTime *arg1 = (wxDateTime *) 0 ;
24806 bool arg2 = (bool) false ;
24807 wxDateTime *result = 0 ;
24808 void *argp1 = 0 ;
24809 int res1 = 0 ;
24810 bool val2 ;
24811 int ecode2 = 0 ;
24812 PyObject * obj0 = 0 ;
24813 PyObject * obj1 = 0 ;
24814 char * kwnames[] = {
24815 (char *) "self",(char *) "noDST", NULL
24816 };
24817
24818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24820 if (!SWIG_IsOK(res1)) {
24821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24822 }
24823 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24824 if (obj1) {
24825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24826 if (!SWIG_IsOK(ecode2)) {
24827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24828 }
24829 arg2 = static_cast< bool >(val2);
24830 }
24831 {
24832 PyThreadState* __tstate = wxPyBeginAllowThreads();
24833 {
24834 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24835 result = (wxDateTime *) &_result_ref;
24836 }
24837 wxPyEndAllowThreads(__tstate);
24838 if (PyErr_Occurred()) SWIG_fail;
24839 }
24840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24841 return resultobj;
24842 fail:
24843 return NULL;
24844 }
24845
24846
24847 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24848 PyObject *resultobj = 0;
24849 wxDateTime *arg1 = (wxDateTime *) 0 ;
24850 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24851 int result;
24852 void *argp1 = 0 ;
24853 int res1 = 0 ;
24854 int val2 ;
24855 int ecode2 = 0 ;
24856 PyObject * obj0 = 0 ;
24857 PyObject * obj1 = 0 ;
24858 char * kwnames[] = {
24859 (char *) "self",(char *) "country", NULL
24860 };
24861
24862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24864 if (!SWIG_IsOK(res1)) {
24865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24866 }
24867 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24868 if (obj1) {
24869 ecode2 = SWIG_AsVal_int(obj1, &val2);
24870 if (!SWIG_IsOK(ecode2)) {
24871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24872 }
24873 arg2 = static_cast< wxDateTime::Country >(val2);
24874 }
24875 {
24876 PyThreadState* __tstate = wxPyBeginAllowThreads();
24877 result = (int)(arg1)->IsDST(arg2);
24878 wxPyEndAllowThreads(__tstate);
24879 if (PyErr_Occurred()) SWIG_fail;
24880 }
24881 resultobj = SWIG_From_int(static_cast< int >(result));
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24889 PyObject *resultobj = 0;
24890 wxDateTime *arg1 = (wxDateTime *) 0 ;
24891 bool result;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 PyObject *swig_obj[1] ;
24895
24896 if (!args) SWIG_fail;
24897 swig_obj[0] = args;
24898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24901 }
24902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (bool)((wxDateTime const *)arg1)->IsValid();
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 {
24910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24911 }
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24919 PyObject *resultobj = 0;
24920 wxDateTime *arg1 = (wxDateTime *) 0 ;
24921 time_t result;
24922 void *argp1 = 0 ;
24923 int res1 = 0 ;
24924 PyObject *swig_obj[1] ;
24925
24926 if (!args) SWIG_fail;
24927 swig_obj[0] = args;
24928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24929 if (!SWIG_IsOK(res1)) {
24930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24931 }
24932 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24947 PyObject *resultobj = 0;
24948 wxDateTime *arg1 = (wxDateTime *) 0 ;
24949 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24950 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24951 int result;
24952 void *argp1 = 0 ;
24953 int res1 = 0 ;
24954 bool temp2 = false ;
24955 PyObject * obj0 = 0 ;
24956 PyObject * obj1 = 0 ;
24957 char * kwnames[] = {
24958 (char *) "self",(char *) "tz", NULL
24959 };
24960
24961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24963 if (!SWIG_IsOK(res1)) {
24964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24965 }
24966 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24967 if (obj1) {
24968 {
24969 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24970 temp2 = true;
24971 }
24972 }
24973 {
24974 PyThreadState* __tstate = wxPyBeginAllowThreads();
24975 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24976 wxPyEndAllowThreads(__tstate);
24977 if (PyErr_Occurred()) SWIG_fail;
24978 }
24979 resultobj = SWIG_From_int(static_cast< int >(result));
24980 {
24981 if (temp2) delete arg2;
24982 }
24983 return resultobj;
24984 fail:
24985 {
24986 if (temp2) delete arg2;
24987 }
24988 return NULL;
24989 }
24990
24991
24992 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24993 PyObject *resultobj = 0;
24994 wxDateTime *arg1 = (wxDateTime *) 0 ;
24995 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24996 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24997 wxDateTime::Month result;
24998 void *argp1 = 0 ;
24999 int res1 = 0 ;
25000 bool temp2 = false ;
25001 PyObject * obj0 = 0 ;
25002 PyObject * obj1 = 0 ;
25003 char * kwnames[] = {
25004 (char *) "self",(char *) "tz", NULL
25005 };
25006
25007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25009 if (!SWIG_IsOK(res1)) {
25010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25011 }
25012 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25013 if (obj1) {
25014 {
25015 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25016 temp2 = true;
25017 }
25018 }
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25022 wxPyEndAllowThreads(__tstate);
25023 if (PyErr_Occurred()) SWIG_fail;
25024 }
25025 resultobj = SWIG_From_int(static_cast< int >(result));
25026 {
25027 if (temp2) delete arg2;
25028 }
25029 return resultobj;
25030 fail:
25031 {
25032 if (temp2) delete arg2;
25033 }
25034 return NULL;
25035 }
25036
25037
25038 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25039 PyObject *resultobj = 0;
25040 wxDateTime *arg1 = (wxDateTime *) 0 ;
25041 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25042 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25043 int result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 bool temp2 = false ;
25047 PyObject * obj0 = 0 ;
25048 PyObject * obj1 = 0 ;
25049 char * kwnames[] = {
25050 (char *) "self",(char *) "tz", NULL
25051 };
25052
25053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25055 if (!SWIG_IsOK(res1)) {
25056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25057 }
25058 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25059 if (obj1) {
25060 {
25061 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25062 temp2 = true;
25063 }
25064 }
25065 {
25066 PyThreadState* __tstate = wxPyBeginAllowThreads();
25067 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25068 wxPyEndAllowThreads(__tstate);
25069 if (PyErr_Occurred()) SWIG_fail;
25070 }
25071 resultobj = SWIG_From_int(static_cast< int >(result));
25072 {
25073 if (temp2) delete arg2;
25074 }
25075 return resultobj;
25076 fail:
25077 {
25078 if (temp2) delete arg2;
25079 }
25080 return NULL;
25081 }
25082
25083
25084 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25085 PyObject *resultobj = 0;
25086 wxDateTime *arg1 = (wxDateTime *) 0 ;
25087 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25088 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25089 wxDateTime::WeekDay result;
25090 void *argp1 = 0 ;
25091 int res1 = 0 ;
25092 bool temp2 = false ;
25093 PyObject * obj0 = 0 ;
25094 PyObject * obj1 = 0 ;
25095 char * kwnames[] = {
25096 (char *) "self",(char *) "tz", NULL
25097 };
25098
25099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25101 if (!SWIG_IsOK(res1)) {
25102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25103 }
25104 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25105 if (obj1) {
25106 {
25107 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25108 temp2 = true;
25109 }
25110 }
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25114 wxPyEndAllowThreads(__tstate);
25115 if (PyErr_Occurred()) SWIG_fail;
25116 }
25117 resultobj = SWIG_From_int(static_cast< int >(result));
25118 {
25119 if (temp2) delete arg2;
25120 }
25121 return resultobj;
25122 fail:
25123 {
25124 if (temp2) delete arg2;
25125 }
25126 return NULL;
25127 }
25128
25129
25130 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25131 PyObject *resultobj = 0;
25132 wxDateTime *arg1 = (wxDateTime *) 0 ;
25133 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25134 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25135 int result;
25136 void *argp1 = 0 ;
25137 int res1 = 0 ;
25138 bool temp2 = false ;
25139 PyObject * obj0 = 0 ;
25140 PyObject * obj1 = 0 ;
25141 char * kwnames[] = {
25142 (char *) "self",(char *) "tz", NULL
25143 };
25144
25145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25147 if (!SWIG_IsOK(res1)) {
25148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25149 }
25150 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25151 if (obj1) {
25152 {
25153 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25154 temp2 = true;
25155 }
25156 }
25157 {
25158 PyThreadState* __tstate = wxPyBeginAllowThreads();
25159 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25160 wxPyEndAllowThreads(__tstate);
25161 if (PyErr_Occurred()) SWIG_fail;
25162 }
25163 resultobj = SWIG_From_int(static_cast< int >(result));
25164 {
25165 if (temp2) delete arg2;
25166 }
25167 return resultobj;
25168 fail:
25169 {
25170 if (temp2) delete arg2;
25171 }
25172 return NULL;
25173 }
25174
25175
25176 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25177 PyObject *resultobj = 0;
25178 wxDateTime *arg1 = (wxDateTime *) 0 ;
25179 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25180 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25181 int result;
25182 void *argp1 = 0 ;
25183 int res1 = 0 ;
25184 bool temp2 = false ;
25185 PyObject * obj0 = 0 ;
25186 PyObject * obj1 = 0 ;
25187 char * kwnames[] = {
25188 (char *) "self",(char *) "tz", NULL
25189 };
25190
25191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25193 if (!SWIG_IsOK(res1)) {
25194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25195 }
25196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25197 if (obj1) {
25198 {
25199 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25200 temp2 = true;
25201 }
25202 }
25203 {
25204 PyThreadState* __tstate = wxPyBeginAllowThreads();
25205 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25206 wxPyEndAllowThreads(__tstate);
25207 if (PyErr_Occurred()) SWIG_fail;
25208 }
25209 resultobj = SWIG_From_int(static_cast< int >(result));
25210 {
25211 if (temp2) delete arg2;
25212 }
25213 return resultobj;
25214 fail:
25215 {
25216 if (temp2) delete arg2;
25217 }
25218 return NULL;
25219 }
25220
25221
25222 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25223 PyObject *resultobj = 0;
25224 wxDateTime *arg1 = (wxDateTime *) 0 ;
25225 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25226 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25227 int result;
25228 void *argp1 = 0 ;
25229 int res1 = 0 ;
25230 bool temp2 = false ;
25231 PyObject * obj0 = 0 ;
25232 PyObject * obj1 = 0 ;
25233 char * kwnames[] = {
25234 (char *) "self",(char *) "tz", NULL
25235 };
25236
25237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25239 if (!SWIG_IsOK(res1)) {
25240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25241 }
25242 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25243 if (obj1) {
25244 {
25245 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25246 temp2 = true;
25247 }
25248 }
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25252 wxPyEndAllowThreads(__tstate);
25253 if (PyErr_Occurred()) SWIG_fail;
25254 }
25255 resultobj = SWIG_From_int(static_cast< int >(result));
25256 {
25257 if (temp2) delete arg2;
25258 }
25259 return resultobj;
25260 fail:
25261 {
25262 if (temp2) delete arg2;
25263 }
25264 return NULL;
25265 }
25266
25267
25268 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25269 PyObject *resultobj = 0;
25270 wxDateTime *arg1 = (wxDateTime *) 0 ;
25271 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25272 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25273 int result;
25274 void *argp1 = 0 ;
25275 int res1 = 0 ;
25276 bool temp2 = false ;
25277 PyObject * obj0 = 0 ;
25278 PyObject * obj1 = 0 ;
25279 char * kwnames[] = {
25280 (char *) "self",(char *) "tz", NULL
25281 };
25282
25283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25285 if (!SWIG_IsOK(res1)) {
25286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25287 }
25288 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25289 if (obj1) {
25290 {
25291 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25292 temp2 = true;
25293 }
25294 }
25295 {
25296 PyThreadState* __tstate = wxPyBeginAllowThreads();
25297 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25298 wxPyEndAllowThreads(__tstate);
25299 if (PyErr_Occurred()) SWIG_fail;
25300 }
25301 resultobj = SWIG_From_int(static_cast< int >(result));
25302 {
25303 if (temp2) delete arg2;
25304 }
25305 return resultobj;
25306 fail:
25307 {
25308 if (temp2) delete arg2;
25309 }
25310 return NULL;
25311 }
25312
25313
25314 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj = 0;
25316 wxDateTime *arg1 = (wxDateTime *) 0 ;
25317 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25318 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25319 int result;
25320 void *argp1 = 0 ;
25321 int res1 = 0 ;
25322 bool temp2 = false ;
25323 PyObject * obj0 = 0 ;
25324 PyObject * obj1 = 0 ;
25325 char * kwnames[] = {
25326 (char *) "self",(char *) "tz", NULL
25327 };
25328
25329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25331 if (!SWIG_IsOK(res1)) {
25332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25333 }
25334 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25335 if (obj1) {
25336 {
25337 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25338 temp2 = true;
25339 }
25340 }
25341 {
25342 PyThreadState* __tstate = wxPyBeginAllowThreads();
25343 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25344 wxPyEndAllowThreads(__tstate);
25345 if (PyErr_Occurred()) SWIG_fail;
25346 }
25347 resultobj = SWIG_From_int(static_cast< int >(result));
25348 {
25349 if (temp2) delete arg2;
25350 }
25351 return resultobj;
25352 fail:
25353 {
25354 if (temp2) delete arg2;
25355 }
25356 return NULL;
25357 }
25358
25359
25360 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25361 PyObject *resultobj = 0;
25362 wxDateTime *arg1 = (wxDateTime *) 0 ;
25363 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25364 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25365 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25366 int result;
25367 void *argp1 = 0 ;
25368 int res1 = 0 ;
25369 int val2 ;
25370 int ecode2 = 0 ;
25371 bool temp3 = false ;
25372 PyObject * obj0 = 0 ;
25373 PyObject * obj1 = 0 ;
25374 PyObject * obj2 = 0 ;
25375 char * kwnames[] = {
25376 (char *) "self",(char *) "flags",(char *) "tz", NULL
25377 };
25378
25379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25381 if (!SWIG_IsOK(res1)) {
25382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25383 }
25384 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25385 if (obj1) {
25386 ecode2 = SWIG_AsVal_int(obj1, &val2);
25387 if (!SWIG_IsOK(ecode2)) {
25388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25389 }
25390 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25391 }
25392 if (obj2) {
25393 {
25394 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25395 temp3 = true;
25396 }
25397 }
25398 {
25399 PyThreadState* __tstate = wxPyBeginAllowThreads();
25400 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25401 wxPyEndAllowThreads(__tstate);
25402 if (PyErr_Occurred()) SWIG_fail;
25403 }
25404 resultobj = SWIG_From_int(static_cast< int >(result));
25405 {
25406 if (temp3) delete arg3;
25407 }
25408 return resultobj;
25409 fail:
25410 {
25411 if (temp3) delete arg3;
25412 }
25413 return NULL;
25414 }
25415
25416
25417 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25418 PyObject *resultobj = 0;
25419 wxDateTime *arg1 = (wxDateTime *) 0 ;
25420 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25421 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25422 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25423 int result;
25424 void *argp1 = 0 ;
25425 int res1 = 0 ;
25426 int val2 ;
25427 int ecode2 = 0 ;
25428 bool temp3 = false ;
25429 PyObject * obj0 = 0 ;
25430 PyObject * obj1 = 0 ;
25431 PyObject * obj2 = 0 ;
25432 char * kwnames[] = {
25433 (char *) "self",(char *) "flags",(char *) "tz", NULL
25434 };
25435
25436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25438 if (!SWIG_IsOK(res1)) {
25439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25440 }
25441 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25442 if (obj1) {
25443 ecode2 = SWIG_AsVal_int(obj1, &val2);
25444 if (!SWIG_IsOK(ecode2)) {
25445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25446 }
25447 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25448 }
25449 if (obj2) {
25450 {
25451 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25452 temp3 = true;
25453 }
25454 }
25455 {
25456 PyThreadState* __tstate = wxPyBeginAllowThreads();
25457 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25458 wxPyEndAllowThreads(__tstate);
25459 if (PyErr_Occurred()) SWIG_fail;
25460 }
25461 resultobj = SWIG_From_int(static_cast< int >(result));
25462 {
25463 if (temp3) delete arg3;
25464 }
25465 return resultobj;
25466 fail:
25467 {
25468 if (temp3) delete arg3;
25469 }
25470 return NULL;
25471 }
25472
25473
25474 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25475 PyObject *resultobj = 0;
25476 wxDateTime *arg1 = (wxDateTime *) 0 ;
25477 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25478 bool result;
25479 void *argp1 = 0 ;
25480 int res1 = 0 ;
25481 int val2 ;
25482 int ecode2 = 0 ;
25483 PyObject * obj0 = 0 ;
25484 PyObject * obj1 = 0 ;
25485 char * kwnames[] = {
25486 (char *) "self",(char *) "country", NULL
25487 };
25488
25489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25491 if (!SWIG_IsOK(res1)) {
25492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25493 }
25494 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25495 if (obj1) {
25496 ecode2 = SWIG_AsVal_int(obj1, &val2);
25497 if (!SWIG_IsOK(ecode2)) {
25498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25499 }
25500 arg2 = static_cast< wxDateTime::Country >(val2);
25501 }
25502 {
25503 PyThreadState* __tstate = wxPyBeginAllowThreads();
25504 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25505 wxPyEndAllowThreads(__tstate);
25506 if (PyErr_Occurred()) SWIG_fail;
25507 }
25508 {
25509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25510 }
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25518 PyObject *resultobj = 0;
25519 wxDateTime *arg1 = (wxDateTime *) 0 ;
25520 wxDateTime *arg2 = 0 ;
25521 bool result;
25522 void *argp1 = 0 ;
25523 int res1 = 0 ;
25524 void *argp2 = 0 ;
25525 int res2 = 0 ;
25526 PyObject * obj0 = 0 ;
25527 PyObject * obj1 = 0 ;
25528 char * kwnames[] = {
25529 (char *) "self",(char *) "datetime", NULL
25530 };
25531
25532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25534 if (!SWIG_IsOK(res1)) {
25535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25536 }
25537 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25539 if (!SWIG_IsOK(res2)) {
25540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25541 }
25542 if (!argp2) {
25543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25544 }
25545 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25549 wxPyEndAllowThreads(__tstate);
25550 if (PyErr_Occurred()) SWIG_fail;
25551 }
25552 {
25553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25554 }
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25562 PyObject *resultobj = 0;
25563 wxDateTime *arg1 = (wxDateTime *) 0 ;
25564 wxDateTime *arg2 = 0 ;
25565 bool result;
25566 void *argp1 = 0 ;
25567 int res1 = 0 ;
25568 void *argp2 = 0 ;
25569 int res2 = 0 ;
25570 PyObject * obj0 = 0 ;
25571 PyObject * obj1 = 0 ;
25572 char * kwnames[] = {
25573 (char *) "self",(char *) "datetime", NULL
25574 };
25575
25576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25578 if (!SWIG_IsOK(res1)) {
25579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25580 }
25581 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25582 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25583 if (!SWIG_IsOK(res2)) {
25584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25585 }
25586 if (!argp2) {
25587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25588 }
25589 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25590 {
25591 PyThreadState* __tstate = wxPyBeginAllowThreads();
25592 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25593 wxPyEndAllowThreads(__tstate);
25594 if (PyErr_Occurred()) SWIG_fail;
25595 }
25596 {
25597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25598 }
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25606 PyObject *resultobj = 0;
25607 wxDateTime *arg1 = (wxDateTime *) 0 ;
25608 wxDateTime *arg2 = 0 ;
25609 bool result;
25610 void *argp1 = 0 ;
25611 int res1 = 0 ;
25612 void *argp2 = 0 ;
25613 int res2 = 0 ;
25614 PyObject * obj0 = 0 ;
25615 PyObject * obj1 = 0 ;
25616 char * kwnames[] = {
25617 (char *) "self",(char *) "datetime", NULL
25618 };
25619
25620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25622 if (!SWIG_IsOK(res1)) {
25623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25624 }
25625 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25626 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25627 if (!SWIG_IsOK(res2)) {
25628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25629 }
25630 if (!argp2) {
25631 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25632 }
25633 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 {
25641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25642 }
25643 return resultobj;
25644 fail:
25645 return NULL;
25646 }
25647
25648
25649 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25650 PyObject *resultobj = 0;
25651 wxDateTime *arg1 = (wxDateTime *) 0 ;
25652 wxDateTime *arg2 = 0 ;
25653 wxDateTime *arg3 = 0 ;
25654 bool result;
25655 void *argp1 = 0 ;
25656 int res1 = 0 ;
25657 void *argp2 = 0 ;
25658 int res2 = 0 ;
25659 void *argp3 = 0 ;
25660 int res3 = 0 ;
25661 PyObject * obj0 = 0 ;
25662 PyObject * obj1 = 0 ;
25663 PyObject * obj2 = 0 ;
25664 char * kwnames[] = {
25665 (char *) "self",(char *) "t1",(char *) "t2", NULL
25666 };
25667
25668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25670 if (!SWIG_IsOK(res1)) {
25671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25672 }
25673 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25674 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25675 if (!SWIG_IsOK(res2)) {
25676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25677 }
25678 if (!argp2) {
25679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25680 }
25681 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25682 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25683 if (!SWIG_IsOK(res3)) {
25684 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25685 }
25686 if (!argp3) {
25687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25688 }
25689 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25690 {
25691 PyThreadState* __tstate = wxPyBeginAllowThreads();
25692 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25693 wxPyEndAllowThreads(__tstate);
25694 if (PyErr_Occurred()) SWIG_fail;
25695 }
25696 {
25697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25698 }
25699 return resultobj;
25700 fail:
25701 return NULL;
25702 }
25703
25704
25705 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25706 PyObject *resultobj = 0;
25707 wxDateTime *arg1 = (wxDateTime *) 0 ;
25708 wxDateTime *arg2 = 0 ;
25709 wxDateTime *arg3 = 0 ;
25710 bool result;
25711 void *argp1 = 0 ;
25712 int res1 = 0 ;
25713 void *argp2 = 0 ;
25714 int res2 = 0 ;
25715 void *argp3 = 0 ;
25716 int res3 = 0 ;
25717 PyObject * obj0 = 0 ;
25718 PyObject * obj1 = 0 ;
25719 PyObject * obj2 = 0 ;
25720 char * kwnames[] = {
25721 (char *) "self",(char *) "t1",(char *) "t2", NULL
25722 };
25723
25724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25726 if (!SWIG_IsOK(res1)) {
25727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25728 }
25729 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25730 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25731 if (!SWIG_IsOK(res2)) {
25732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25733 }
25734 if (!argp2) {
25735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25736 }
25737 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25738 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25739 if (!SWIG_IsOK(res3)) {
25740 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25741 }
25742 if (!argp3) {
25743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25744 }
25745 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25746 {
25747 PyThreadState* __tstate = wxPyBeginAllowThreads();
25748 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25749 wxPyEndAllowThreads(__tstate);
25750 if (PyErr_Occurred()) SWIG_fail;
25751 }
25752 {
25753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25754 }
25755 return resultobj;
25756 fail:
25757 return NULL;
25758 }
25759
25760
25761 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25762 PyObject *resultobj = 0;
25763 wxDateTime *arg1 = (wxDateTime *) 0 ;
25764 wxDateTime *arg2 = 0 ;
25765 bool result;
25766 void *argp1 = 0 ;
25767 int res1 = 0 ;
25768 void *argp2 = 0 ;
25769 int res2 = 0 ;
25770 PyObject * obj0 = 0 ;
25771 PyObject * obj1 = 0 ;
25772 char * kwnames[] = {
25773 (char *) "self",(char *) "dt", NULL
25774 };
25775
25776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25778 if (!SWIG_IsOK(res1)) {
25779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25780 }
25781 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25782 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25783 if (!SWIG_IsOK(res2)) {
25784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25785 }
25786 if (!argp2) {
25787 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25788 }
25789 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25790 {
25791 PyThreadState* __tstate = wxPyBeginAllowThreads();
25792 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25793 wxPyEndAllowThreads(__tstate);
25794 if (PyErr_Occurred()) SWIG_fail;
25795 }
25796 {
25797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25798 }
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj = 0;
25807 wxDateTime *arg1 = (wxDateTime *) 0 ;
25808 wxDateTime *arg2 = 0 ;
25809 bool result;
25810 void *argp1 = 0 ;
25811 int res1 = 0 ;
25812 void *argp2 = 0 ;
25813 int res2 = 0 ;
25814 PyObject * obj0 = 0 ;
25815 PyObject * obj1 = 0 ;
25816 char * kwnames[] = {
25817 (char *) "self",(char *) "dt", NULL
25818 };
25819
25820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25822 if (!SWIG_IsOK(res1)) {
25823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25824 }
25825 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25826 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25827 if (!SWIG_IsOK(res2)) {
25828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25829 }
25830 if (!argp2) {
25831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25832 }
25833 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25834 {
25835 PyThreadState* __tstate = wxPyBeginAllowThreads();
25836 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 {
25841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25842 }
25843 return resultobj;
25844 fail:
25845 return NULL;
25846 }
25847
25848
25849 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25850 PyObject *resultobj = 0;
25851 wxDateTime *arg1 = (wxDateTime *) 0 ;
25852 wxDateTime *arg2 = 0 ;
25853 wxTimeSpan *arg3 = 0 ;
25854 bool result;
25855 void *argp1 = 0 ;
25856 int res1 = 0 ;
25857 void *argp2 = 0 ;
25858 int res2 = 0 ;
25859 void *argp3 = 0 ;
25860 int res3 = 0 ;
25861 PyObject * obj0 = 0 ;
25862 PyObject * obj1 = 0 ;
25863 PyObject * obj2 = 0 ;
25864 char * kwnames[] = {
25865 (char *) "self",(char *) "dt",(char *) "ts", NULL
25866 };
25867
25868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25870 if (!SWIG_IsOK(res1)) {
25871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25872 }
25873 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25874 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25875 if (!SWIG_IsOK(res2)) {
25876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25877 }
25878 if (!argp2) {
25879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25880 }
25881 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25882 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25883 if (!SWIG_IsOK(res3)) {
25884 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25885 }
25886 if (!argp3) {
25887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25888 }
25889 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 {
25897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25898 }
25899 return resultobj;
25900 fail:
25901 return NULL;
25902 }
25903
25904
25905 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25906 PyObject *resultobj = 0;
25907 wxDateTime *arg1 = (wxDateTime *) 0 ;
25908 wxTimeSpan *arg2 = 0 ;
25909 wxDateTime *result = 0 ;
25910 void *argp1 = 0 ;
25911 int res1 = 0 ;
25912 void *argp2 = 0 ;
25913 int res2 = 0 ;
25914 PyObject * obj0 = 0 ;
25915 PyObject * obj1 = 0 ;
25916 char * kwnames[] = {
25917 (char *) "self",(char *) "diff", NULL
25918 };
25919
25920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25922 if (!SWIG_IsOK(res1)) {
25923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25924 }
25925 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25927 if (!SWIG_IsOK(res2)) {
25928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25929 }
25930 if (!argp2) {
25931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25932 }
25933 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 {
25937 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25938 result = (wxDateTime *) &_result_ref;
25939 }
25940 wxPyEndAllowThreads(__tstate);
25941 if (PyErr_Occurred()) SWIG_fail;
25942 }
25943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25951 PyObject *resultobj = 0;
25952 wxDateTime *arg1 = (wxDateTime *) 0 ;
25953 wxDateSpan *arg2 = 0 ;
25954 wxDateTime *result = 0 ;
25955 void *argp1 = 0 ;
25956 int res1 = 0 ;
25957 void *argp2 = 0 ;
25958 int res2 = 0 ;
25959 PyObject * obj0 = 0 ;
25960 PyObject * obj1 = 0 ;
25961 char * kwnames[] = {
25962 (char *) "self",(char *) "diff", NULL
25963 };
25964
25965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25967 if (!SWIG_IsOK(res1)) {
25968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25969 }
25970 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25971 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25972 if (!SWIG_IsOK(res2)) {
25973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25974 }
25975 if (!argp2) {
25976 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25977 }
25978 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25979 {
25980 PyThreadState* __tstate = wxPyBeginAllowThreads();
25981 {
25982 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25983 result = (wxDateTime *) &_result_ref;
25984 }
25985 wxPyEndAllowThreads(__tstate);
25986 if (PyErr_Occurred()) SWIG_fail;
25987 }
25988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25989 return resultobj;
25990 fail:
25991 return NULL;
25992 }
25993
25994
25995 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25996 PyObject *resultobj = 0;
25997 wxDateTime *arg1 = (wxDateTime *) 0 ;
25998 wxTimeSpan *arg2 = 0 ;
25999 wxDateTime *result = 0 ;
26000 void *argp1 = 0 ;
26001 int res1 = 0 ;
26002 void *argp2 = 0 ;
26003 int res2 = 0 ;
26004 PyObject * obj0 = 0 ;
26005 PyObject * obj1 = 0 ;
26006 char * kwnames[] = {
26007 (char *) "self",(char *) "diff", NULL
26008 };
26009
26010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26012 if (!SWIG_IsOK(res1)) {
26013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26014 }
26015 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26016 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26017 if (!SWIG_IsOK(res2)) {
26018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26019 }
26020 if (!argp2) {
26021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26022 }
26023 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26024 {
26025 PyThreadState* __tstate = wxPyBeginAllowThreads();
26026 {
26027 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26028 result = (wxDateTime *) &_result_ref;
26029 }
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26041 PyObject *resultobj = 0;
26042 wxDateTime *arg1 = (wxDateTime *) 0 ;
26043 wxDateSpan *arg2 = 0 ;
26044 wxDateTime *result = 0 ;
26045 void *argp1 = 0 ;
26046 int res1 = 0 ;
26047 void *argp2 = 0 ;
26048 int res2 = 0 ;
26049 PyObject * obj0 = 0 ;
26050 PyObject * obj1 = 0 ;
26051 char * kwnames[] = {
26052 (char *) "self",(char *) "diff", NULL
26053 };
26054
26055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26057 if (!SWIG_IsOK(res1)) {
26058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26059 }
26060 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26062 if (!SWIG_IsOK(res2)) {
26063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26064 }
26065 if (!argp2) {
26066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26067 }
26068 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 {
26072 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26073 result = (wxDateTime *) &_result_ref;
26074 }
26075 wxPyEndAllowThreads(__tstate);
26076 if (PyErr_Occurred()) SWIG_fail;
26077 }
26078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26079 return resultobj;
26080 fail:
26081 return NULL;
26082 }
26083
26084
26085 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26086 PyObject *resultobj = 0;
26087 wxDateTime *arg1 = (wxDateTime *) 0 ;
26088 wxDateTime *arg2 = 0 ;
26089 wxTimeSpan result;
26090 void *argp1 = 0 ;
26091 int res1 = 0 ;
26092 void *argp2 = 0 ;
26093 int res2 = 0 ;
26094 PyObject * obj0 = 0 ;
26095 PyObject * obj1 = 0 ;
26096 char * kwnames[] = {
26097 (char *) "self",(char *) "dt", NULL
26098 };
26099
26100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26102 if (!SWIG_IsOK(res1)) {
26103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26104 }
26105 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26106 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26107 if (!SWIG_IsOK(res2)) {
26108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26109 }
26110 if (!argp2) {
26111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26112 }
26113 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26128 PyObject *resultobj = 0;
26129 wxDateTime *arg1 = (wxDateTime *) 0 ;
26130 wxTimeSpan *arg2 = 0 ;
26131 wxDateTime *result = 0 ;
26132 void *argp1 = 0 ;
26133 int res1 = 0 ;
26134 void *argp2 = 0 ;
26135 int res2 = 0 ;
26136
26137 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26139 if (!SWIG_IsOK(res1)) {
26140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26141 }
26142 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26143 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26144 if (!SWIG_IsOK(res2)) {
26145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26146 }
26147 if (!argp2) {
26148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', 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)->operator +=((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, SWIG_POINTER_OWN | 0 );
26161 return resultobj;
26162 fail:
26163 return NULL;
26164 }
26165
26166
26167 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
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
26177 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26179 if (!SWIG_IsOK(res1)) {
26180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26181 }
26182 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26183 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26184 if (!SWIG_IsOK(res2)) {
26185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26186 }
26187 if (!argp2) {
26188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26189 }
26190 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26191 {
26192 PyThreadState* __tstate = wxPyBeginAllowThreads();
26193 {
26194 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26195 result = (wxDateTime *) &_result_ref;
26196 }
26197 wxPyEndAllowThreads(__tstate);
26198 if (PyErr_Occurred()) SWIG_fail;
26199 }
26200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26201 return resultobj;
26202 fail:
26203 return NULL;
26204 }
26205
26206
26207 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26208 int argc;
26209 PyObject *argv[3];
26210
26211 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26212 --argc;
26213 if (argc == 2) {
26214 int _v = 0;
26215 {
26216 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26217 _v = SWIG_CheckState(res);
26218 }
26219 if (!_v) goto check_1;
26220 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26221 }
26222 check_1:
26223
26224 if (argc == 2) {
26225 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26226 }
26227
26228 fail:
26229 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26230 return NULL;
26231 }
26232
26233
26234 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26235 PyObject *resultobj = 0;
26236 wxDateTime *arg1 = (wxDateTime *) 0 ;
26237 wxTimeSpan *arg2 = 0 ;
26238 wxDateTime *result = 0 ;
26239 void *argp1 = 0 ;
26240 int res1 = 0 ;
26241 void *argp2 = 0 ;
26242 int res2 = 0 ;
26243
26244 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26246 if (!SWIG_IsOK(res1)) {
26247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26248 }
26249 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26250 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26251 if (!SWIG_IsOK(res2)) {
26252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26253 }
26254 if (!argp2) {
26255 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26256 }
26257 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26258 {
26259 PyThreadState* __tstate = wxPyBeginAllowThreads();
26260 {
26261 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26262 result = (wxDateTime *) &_result_ref;
26263 }
26264 wxPyEndAllowThreads(__tstate);
26265 if (PyErr_Occurred()) SWIG_fail;
26266 }
26267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26275 PyObject *resultobj = 0;
26276 wxDateTime *arg1 = (wxDateTime *) 0 ;
26277 wxDateSpan *arg2 = 0 ;
26278 wxDateTime *result = 0 ;
26279 void *argp1 = 0 ;
26280 int res1 = 0 ;
26281 void *argp2 = 0 ;
26282 int res2 = 0 ;
26283
26284 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26286 if (!SWIG_IsOK(res1)) {
26287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26288 }
26289 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26290 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26291 if (!SWIG_IsOK(res2)) {
26292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26293 }
26294 if (!argp2) {
26295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26296 }
26297 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26298 {
26299 PyThreadState* __tstate = wxPyBeginAllowThreads();
26300 {
26301 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26302 result = (wxDateTime *) &_result_ref;
26303 }
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26308 return resultobj;
26309 fail:
26310 return NULL;
26311 }
26312
26313
26314 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26315 int argc;
26316 PyObject *argv[3];
26317
26318 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26319 --argc;
26320 if (argc == 2) {
26321 int _v = 0;
26322 {
26323 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26324 _v = SWIG_CheckState(res);
26325 }
26326 if (!_v) goto check_1;
26327 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26328 }
26329 check_1:
26330
26331 if (argc == 2) {
26332 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26333 }
26334
26335 fail:
26336 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26337 return NULL;
26338 }
26339
26340
26341 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26342 PyObject *resultobj = 0;
26343 wxDateTime *arg1 = (wxDateTime *) 0 ;
26344 wxTimeSpan *arg2 = 0 ;
26345 wxDateTime result;
26346 void *argp1 = 0 ;
26347 int res1 = 0 ;
26348 void *argp2 = 0 ;
26349 int res2 = 0 ;
26350
26351 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26353 if (!SWIG_IsOK(res1)) {
26354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26355 }
26356 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26357 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26358 if (!SWIG_IsOK(res2)) {
26359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26360 }
26361 if (!argp2) {
26362 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26363 }
26364 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26379 PyObject *resultobj = 0;
26380 wxDateTime *arg1 = (wxDateTime *) 0 ;
26381 wxDateSpan *arg2 = 0 ;
26382 wxDateTime result;
26383 void *argp1 = 0 ;
26384 int res1 = 0 ;
26385 void *argp2 = 0 ;
26386 int res2 = 0 ;
26387
26388 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26390 if (!SWIG_IsOK(res1)) {
26391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26392 }
26393 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26394 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26395 if (!SWIG_IsOK(res2)) {
26396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26397 }
26398 if (!argp2) {
26399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26400 }
26401 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26402 {
26403 PyThreadState* __tstate = wxPyBeginAllowThreads();
26404 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26405 wxPyEndAllowThreads(__tstate);
26406 if (PyErr_Occurred()) SWIG_fail;
26407 }
26408 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26409 return resultobj;
26410 fail:
26411 return NULL;
26412 }
26413
26414
26415 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26416 int argc;
26417 PyObject *argv[3];
26418
26419 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26420 --argc;
26421 if (argc == 2) {
26422 int _v = 0;
26423 {
26424 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26425 _v = SWIG_CheckState(res);
26426 }
26427 if (!_v) goto check_1;
26428 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26429 }
26430 check_1:
26431
26432 if (argc == 2) {
26433 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26434 }
26435
26436 fail:
26437 Py_INCREF(Py_NotImplemented);
26438 return Py_NotImplemented;
26439 }
26440
26441
26442 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26443 PyObject *resultobj = 0;
26444 wxDateTime *arg1 = (wxDateTime *) 0 ;
26445 wxDateTime *arg2 = 0 ;
26446 wxTimeSpan result;
26447 void *argp1 = 0 ;
26448 int res1 = 0 ;
26449 void *argp2 = 0 ;
26450 int res2 = 0 ;
26451
26452 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26454 if (!SWIG_IsOK(res1)) {
26455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26456 }
26457 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26458 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26459 if (!SWIG_IsOK(res2)) {
26460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26461 }
26462 if (!argp2) {
26463 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26464 }
26465 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26466 {
26467 PyThreadState* __tstate = wxPyBeginAllowThreads();
26468 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26469 wxPyEndAllowThreads(__tstate);
26470 if (PyErr_Occurred()) SWIG_fail;
26471 }
26472 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26473 return resultobj;
26474 fail:
26475 return NULL;
26476 }
26477
26478
26479 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26480 PyObject *resultobj = 0;
26481 wxDateTime *arg1 = (wxDateTime *) 0 ;
26482 wxTimeSpan *arg2 = 0 ;
26483 wxDateTime result;
26484 void *argp1 = 0 ;
26485 int res1 = 0 ;
26486 void *argp2 = 0 ;
26487 int res2 = 0 ;
26488
26489 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26491 if (!SWIG_IsOK(res1)) {
26492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26493 }
26494 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26495 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26496 if (!SWIG_IsOK(res2)) {
26497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26498 }
26499 if (!argp2) {
26500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26501 }
26502 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26503 {
26504 PyThreadState* __tstate = wxPyBeginAllowThreads();
26505 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26506 wxPyEndAllowThreads(__tstate);
26507 if (PyErr_Occurred()) SWIG_fail;
26508 }
26509 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26510 return resultobj;
26511 fail:
26512 return NULL;
26513 }
26514
26515
26516 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26517 PyObject *resultobj = 0;
26518 wxDateTime *arg1 = (wxDateTime *) 0 ;
26519 wxDateSpan *arg2 = 0 ;
26520 wxDateTime result;
26521 void *argp1 = 0 ;
26522 int res1 = 0 ;
26523 void *argp2 = 0 ;
26524 int res2 = 0 ;
26525
26526 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26528 if (!SWIG_IsOK(res1)) {
26529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26530 }
26531 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26532 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26533 if (!SWIG_IsOK(res2)) {
26534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26535 }
26536 if (!argp2) {
26537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26538 }
26539 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26540 {
26541 PyThreadState* __tstate = wxPyBeginAllowThreads();
26542 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26543 wxPyEndAllowThreads(__tstate);
26544 if (PyErr_Occurred()) SWIG_fail;
26545 }
26546 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26547 return resultobj;
26548 fail:
26549 return NULL;
26550 }
26551
26552
26553 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26554 int argc;
26555 PyObject *argv[3];
26556
26557 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26558 --argc;
26559 if (argc == 2) {
26560 int _v = 0;
26561 {
26562 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26563 _v = SWIG_CheckState(res);
26564 }
26565 if (!_v) goto check_1;
26566 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26567 }
26568 check_1:
26569
26570 if (argc == 2) {
26571 int _v = 0;
26572 {
26573 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26574 _v = SWIG_CheckState(res);
26575 }
26576 if (!_v) goto check_2;
26577 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26578 }
26579 check_2:
26580
26581 if (argc == 2) {
26582 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26583 }
26584
26585 fail:
26586 Py_INCREF(Py_NotImplemented);
26587 return Py_NotImplemented;
26588 }
26589
26590
26591 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26592 PyObject *resultobj = 0;
26593 wxDateTime *arg1 = (wxDateTime *) 0 ;
26594 wxDateTime *arg2 = (wxDateTime *) 0 ;
26595 bool result;
26596 void *argp1 = 0 ;
26597 int res1 = 0 ;
26598 void *argp2 = 0 ;
26599 int res2 = 0 ;
26600 PyObject * obj0 = 0 ;
26601 PyObject * obj1 = 0 ;
26602 char * kwnames[] = {
26603 (char *) "self",(char *) "other", NULL
26604 };
26605
26606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26608 if (!SWIG_IsOK(res1)) {
26609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26610 }
26611 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26613 if (!SWIG_IsOK(res2)) {
26614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26615 }
26616 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26625 }
26626 return resultobj;
26627 fail:
26628 return NULL;
26629 }
26630
26631
26632 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26633 PyObject *resultobj = 0;
26634 wxDateTime *arg1 = (wxDateTime *) 0 ;
26635 wxDateTime *arg2 = (wxDateTime *) 0 ;
26636 bool result;
26637 void *argp1 = 0 ;
26638 int res1 = 0 ;
26639 void *argp2 = 0 ;
26640 int res2 = 0 ;
26641 PyObject * obj0 = 0 ;
26642 PyObject * obj1 = 0 ;
26643 char * kwnames[] = {
26644 (char *) "self",(char *) "other", NULL
26645 };
26646
26647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26649 if (!SWIG_IsOK(res1)) {
26650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26651 }
26652 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26654 if (!SWIG_IsOK(res2)) {
26655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26656 }
26657 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26658 {
26659 PyThreadState* __tstate = wxPyBeginAllowThreads();
26660 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26661 wxPyEndAllowThreads(__tstate);
26662 if (PyErr_Occurred()) SWIG_fail;
26663 }
26664 {
26665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26666 }
26667 return resultobj;
26668 fail:
26669 return NULL;
26670 }
26671
26672
26673 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26674 PyObject *resultobj = 0;
26675 wxDateTime *arg1 = (wxDateTime *) 0 ;
26676 wxDateTime *arg2 = (wxDateTime *) 0 ;
26677 bool result;
26678 void *argp1 = 0 ;
26679 int res1 = 0 ;
26680 void *argp2 = 0 ;
26681 int res2 = 0 ;
26682 PyObject * obj0 = 0 ;
26683 PyObject * obj1 = 0 ;
26684 char * kwnames[] = {
26685 (char *) "self",(char *) "other", NULL
26686 };
26687
26688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26690 if (!SWIG_IsOK(res1)) {
26691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26692 }
26693 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26694 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26695 if (!SWIG_IsOK(res2)) {
26696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26697 }
26698 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 {
26706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26707 }
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26715 PyObject *resultobj = 0;
26716 wxDateTime *arg1 = (wxDateTime *) 0 ;
26717 wxDateTime *arg2 = (wxDateTime *) 0 ;
26718 bool result;
26719 void *argp1 = 0 ;
26720 int res1 = 0 ;
26721 void *argp2 = 0 ;
26722 int res2 = 0 ;
26723 PyObject * obj0 = 0 ;
26724 PyObject * obj1 = 0 ;
26725 char * kwnames[] = {
26726 (char *) "self",(char *) "other", NULL
26727 };
26728
26729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26731 if (!SWIG_IsOK(res1)) {
26732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26733 }
26734 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26736 if (!SWIG_IsOK(res2)) {
26737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26738 }
26739 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26740 {
26741 PyThreadState* __tstate = wxPyBeginAllowThreads();
26742 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26743 wxPyEndAllowThreads(__tstate);
26744 if (PyErr_Occurred()) SWIG_fail;
26745 }
26746 {
26747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26748 }
26749 return resultobj;
26750 fail:
26751 return NULL;
26752 }
26753
26754
26755 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj = 0;
26757 wxDateTime *arg1 = (wxDateTime *) 0 ;
26758 wxDateTime *arg2 = (wxDateTime *) 0 ;
26759 bool result;
26760 void *argp1 = 0 ;
26761 int res1 = 0 ;
26762 void *argp2 = 0 ;
26763 int res2 = 0 ;
26764 PyObject * obj0 = 0 ;
26765 PyObject * obj1 = 0 ;
26766 char * kwnames[] = {
26767 (char *) "self",(char *) "other", NULL
26768 };
26769
26770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26772 if (!SWIG_IsOK(res1)) {
26773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26774 }
26775 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26777 if (!SWIG_IsOK(res2)) {
26778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26779 }
26780 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26781 {
26782 PyThreadState* __tstate = wxPyBeginAllowThreads();
26783 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26784 wxPyEndAllowThreads(__tstate);
26785 if (PyErr_Occurred()) SWIG_fail;
26786 }
26787 {
26788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26789 }
26790 return resultobj;
26791 fail:
26792 return NULL;
26793 }
26794
26795
26796 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26797 PyObject *resultobj = 0;
26798 wxDateTime *arg1 = (wxDateTime *) 0 ;
26799 wxDateTime *arg2 = (wxDateTime *) 0 ;
26800 bool result;
26801 void *argp1 = 0 ;
26802 int res1 = 0 ;
26803 void *argp2 = 0 ;
26804 int res2 = 0 ;
26805 PyObject * obj0 = 0 ;
26806 PyObject * obj1 = 0 ;
26807 char * kwnames[] = {
26808 (char *) "self",(char *) "other", NULL
26809 };
26810
26811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26813 if (!SWIG_IsOK(res1)) {
26814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26815 }
26816 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26818 if (!SWIG_IsOK(res2)) {
26819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26820 }
26821 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26822 {
26823 PyThreadState* __tstate = wxPyBeginAllowThreads();
26824 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26825 wxPyEndAllowThreads(__tstate);
26826 if (PyErr_Occurred()) SWIG_fail;
26827 }
26828 {
26829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26830 }
26831 return resultobj;
26832 fail:
26833 return NULL;
26834 }
26835
26836
26837 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26838 PyObject *resultobj = 0;
26839 wxDateTime *arg1 = (wxDateTime *) 0 ;
26840 wxString *arg2 = 0 ;
26841 int result;
26842 void *argp1 = 0 ;
26843 int res1 = 0 ;
26844 bool temp2 = false ;
26845 PyObject * obj0 = 0 ;
26846 PyObject * obj1 = 0 ;
26847 char * kwnames[] = {
26848 (char *) "self",(char *) "date", NULL
26849 };
26850
26851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26853 if (!SWIG_IsOK(res1)) {
26854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26855 }
26856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26857 {
26858 arg2 = wxString_in_helper(obj1);
26859 if (arg2 == NULL) SWIG_fail;
26860 temp2 = true;
26861 }
26862 {
26863 PyThreadState* __tstate = wxPyBeginAllowThreads();
26864 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 resultobj = SWIG_From_int(static_cast< int >(result));
26869 {
26870 if (temp2)
26871 delete arg2;
26872 }
26873 return resultobj;
26874 fail:
26875 {
26876 if (temp2)
26877 delete arg2;
26878 }
26879 return NULL;
26880 }
26881
26882
26883 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26884 PyObject *resultobj = 0;
26885 wxDateTime *arg1 = (wxDateTime *) 0 ;
26886 wxString *arg2 = 0 ;
26887 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26888 wxString *arg3 = (wxString *) &arg3_defvalue ;
26889 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26890 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26891 int result;
26892 void *argp1 = 0 ;
26893 int res1 = 0 ;
26894 bool temp2 = false ;
26895 bool temp3 = false ;
26896 void *argp4 = 0 ;
26897 int res4 = 0 ;
26898 PyObject * obj0 = 0 ;
26899 PyObject * obj1 = 0 ;
26900 PyObject * obj2 = 0 ;
26901 PyObject * obj3 = 0 ;
26902 char * kwnames[] = {
26903 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26904 };
26905
26906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26908 if (!SWIG_IsOK(res1)) {
26909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26910 }
26911 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26912 {
26913 arg2 = wxString_in_helper(obj1);
26914 if (arg2 == NULL) SWIG_fail;
26915 temp2 = true;
26916 }
26917 if (obj2) {
26918 {
26919 arg3 = wxString_in_helper(obj2);
26920 if (arg3 == NULL) SWIG_fail;
26921 temp3 = true;
26922 }
26923 }
26924 if (obj3) {
26925 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26926 if (!SWIG_IsOK(res4)) {
26927 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26928 }
26929 if (!argp4) {
26930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26931 }
26932 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26933 }
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26937 wxPyEndAllowThreads(__tstate);
26938 if (PyErr_Occurred()) SWIG_fail;
26939 }
26940 resultobj = SWIG_From_int(static_cast< int >(result));
26941 {
26942 if (temp2)
26943 delete arg2;
26944 }
26945 {
26946 if (temp3)
26947 delete arg3;
26948 }
26949 return resultobj;
26950 fail:
26951 {
26952 if (temp2)
26953 delete arg2;
26954 }
26955 {
26956 if (temp3)
26957 delete arg3;
26958 }
26959 return NULL;
26960 }
26961
26962
26963 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26964 PyObject *resultobj = 0;
26965 wxDateTime *arg1 = (wxDateTime *) 0 ;
26966 wxString *arg2 = 0 ;
26967 int result;
26968 void *argp1 = 0 ;
26969 int res1 = 0 ;
26970 bool temp2 = false ;
26971 PyObject * obj0 = 0 ;
26972 PyObject * obj1 = 0 ;
26973 char * kwnames[] = {
26974 (char *) "self",(char *) "datetime", NULL
26975 };
26976
26977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26979 if (!SWIG_IsOK(res1)) {
26980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26981 }
26982 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26983 {
26984 arg2 = wxString_in_helper(obj1);
26985 if (arg2 == NULL) SWIG_fail;
26986 temp2 = true;
26987 }
26988 {
26989 PyThreadState* __tstate = wxPyBeginAllowThreads();
26990 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 resultobj = SWIG_From_int(static_cast< int >(result));
26995 {
26996 if (temp2)
26997 delete arg2;
26998 }
26999 return resultobj;
27000 fail:
27001 {
27002 if (temp2)
27003 delete arg2;
27004 }
27005 return NULL;
27006 }
27007
27008
27009 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27010 PyObject *resultobj = 0;
27011 wxDateTime *arg1 = (wxDateTime *) 0 ;
27012 wxString *arg2 = 0 ;
27013 int result;
27014 void *argp1 = 0 ;
27015 int res1 = 0 ;
27016 bool temp2 = false ;
27017 PyObject * obj0 = 0 ;
27018 PyObject * obj1 = 0 ;
27019 char * kwnames[] = {
27020 (char *) "self",(char *) "date", NULL
27021 };
27022
27023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27025 if (!SWIG_IsOK(res1)) {
27026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27027 }
27028 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27029 {
27030 arg2 = wxString_in_helper(obj1);
27031 if (arg2 == NULL) SWIG_fail;
27032 temp2 = true;
27033 }
27034 {
27035 PyThreadState* __tstate = wxPyBeginAllowThreads();
27036 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27037 wxPyEndAllowThreads(__tstate);
27038 if (PyErr_Occurred()) SWIG_fail;
27039 }
27040 resultobj = SWIG_From_int(static_cast< int >(result));
27041 {
27042 if (temp2)
27043 delete arg2;
27044 }
27045 return resultobj;
27046 fail:
27047 {
27048 if (temp2)
27049 delete arg2;
27050 }
27051 return NULL;
27052 }
27053
27054
27055 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27056 PyObject *resultobj = 0;
27057 wxDateTime *arg1 = (wxDateTime *) 0 ;
27058 wxString *arg2 = 0 ;
27059 int result;
27060 void *argp1 = 0 ;
27061 int res1 = 0 ;
27062 bool temp2 = false ;
27063 PyObject * obj0 = 0 ;
27064 PyObject * obj1 = 0 ;
27065 char * kwnames[] = {
27066 (char *) "self",(char *) "time", NULL
27067 };
27068
27069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27071 if (!SWIG_IsOK(res1)) {
27072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27073 }
27074 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27075 {
27076 arg2 = wxString_in_helper(obj1);
27077 if (arg2 == NULL) SWIG_fail;
27078 temp2 = true;
27079 }
27080 {
27081 PyThreadState* __tstate = wxPyBeginAllowThreads();
27082 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27083 wxPyEndAllowThreads(__tstate);
27084 if (PyErr_Occurred()) SWIG_fail;
27085 }
27086 resultobj = SWIG_From_int(static_cast< int >(result));
27087 {
27088 if (temp2)
27089 delete arg2;
27090 }
27091 return resultobj;
27092 fail:
27093 {
27094 if (temp2)
27095 delete arg2;
27096 }
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27102 PyObject *resultobj = 0;
27103 wxDateTime *arg1 = (wxDateTime *) 0 ;
27104 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27105 wxString *arg2 = (wxString *) &arg2_defvalue ;
27106 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27107 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27108 wxString result;
27109 void *argp1 = 0 ;
27110 int res1 = 0 ;
27111 bool temp2 = false ;
27112 bool temp3 = false ;
27113 PyObject * obj0 = 0 ;
27114 PyObject * obj1 = 0 ;
27115 PyObject * obj2 = 0 ;
27116 char * kwnames[] = {
27117 (char *) "self",(char *) "format",(char *) "tz", NULL
27118 };
27119
27120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27122 if (!SWIG_IsOK(res1)) {
27123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27124 }
27125 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27126 if (obj1) {
27127 {
27128 arg2 = wxString_in_helper(obj1);
27129 if (arg2 == NULL) SWIG_fail;
27130 temp2 = true;
27131 }
27132 }
27133 if (obj2) {
27134 {
27135 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27136 temp3 = true;
27137 }
27138 }
27139 {
27140 PyThreadState* __tstate = wxPyBeginAllowThreads();
27141 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27142 wxPyEndAllowThreads(__tstate);
27143 if (PyErr_Occurred()) SWIG_fail;
27144 }
27145 {
27146 #if wxUSE_UNICODE
27147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27148 #else
27149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27150 #endif
27151 }
27152 {
27153 if (temp2)
27154 delete arg2;
27155 }
27156 {
27157 if (temp3) delete arg3;
27158 }
27159 return resultobj;
27160 fail:
27161 {
27162 if (temp2)
27163 delete arg2;
27164 }
27165 {
27166 if (temp3) delete arg3;
27167 }
27168 return NULL;
27169 }
27170
27171
27172 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27173 PyObject *resultobj = 0;
27174 wxDateTime *arg1 = (wxDateTime *) 0 ;
27175 wxString result;
27176 void *argp1 = 0 ;
27177 int res1 = 0 ;
27178 PyObject *swig_obj[1] ;
27179
27180 if (!args) SWIG_fail;
27181 swig_obj[0] = args;
27182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27183 if (!SWIG_IsOK(res1)) {
27184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27185 }
27186 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27187 {
27188 PyThreadState* __tstate = wxPyBeginAllowThreads();
27189 result = ((wxDateTime const *)arg1)->FormatDate();
27190 wxPyEndAllowThreads(__tstate);
27191 if (PyErr_Occurred()) SWIG_fail;
27192 }
27193 {
27194 #if wxUSE_UNICODE
27195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27196 #else
27197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27198 #endif
27199 }
27200 return resultobj;
27201 fail:
27202 return NULL;
27203 }
27204
27205
27206 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27207 PyObject *resultobj = 0;
27208 wxDateTime *arg1 = (wxDateTime *) 0 ;
27209 wxString result;
27210 void *argp1 = 0 ;
27211 int res1 = 0 ;
27212 PyObject *swig_obj[1] ;
27213
27214 if (!args) SWIG_fail;
27215 swig_obj[0] = args;
27216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27217 if (!SWIG_IsOK(res1)) {
27218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27219 }
27220 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 result = ((wxDateTime const *)arg1)->FormatTime();
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 {
27228 #if wxUSE_UNICODE
27229 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27230 #else
27231 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27232 #endif
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27241 PyObject *resultobj = 0;
27242 wxDateTime *arg1 = (wxDateTime *) 0 ;
27243 wxString result;
27244 void *argp1 = 0 ;
27245 int res1 = 0 ;
27246 PyObject *swig_obj[1] ;
27247
27248 if (!args) SWIG_fail;
27249 swig_obj[0] = args;
27250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27251 if (!SWIG_IsOK(res1)) {
27252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27253 }
27254 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27255 {
27256 PyThreadState* __tstate = wxPyBeginAllowThreads();
27257 result = ((wxDateTime const *)arg1)->FormatISODate();
27258 wxPyEndAllowThreads(__tstate);
27259 if (PyErr_Occurred()) SWIG_fail;
27260 }
27261 {
27262 #if wxUSE_UNICODE
27263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27264 #else
27265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27266 #endif
27267 }
27268 return resultobj;
27269 fail:
27270 return NULL;
27271 }
27272
27273
27274 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27275 PyObject *resultobj = 0;
27276 wxDateTime *arg1 = (wxDateTime *) 0 ;
27277 wxString result;
27278 void *argp1 = 0 ;
27279 int res1 = 0 ;
27280 PyObject *swig_obj[1] ;
27281
27282 if (!args) SWIG_fail;
27283 swig_obj[0] = args;
27284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27285 if (!SWIG_IsOK(res1)) {
27286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27287 }
27288 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27289 {
27290 PyThreadState* __tstate = wxPyBeginAllowThreads();
27291 result = ((wxDateTime const *)arg1)->FormatISOTime();
27292 wxPyEndAllowThreads(__tstate);
27293 if (PyErr_Occurred()) SWIG_fail;
27294 }
27295 {
27296 #if wxUSE_UNICODE
27297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27298 #else
27299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27300 #endif
27301 }
27302 return resultobj;
27303 fail:
27304 return NULL;
27305 }
27306
27307
27308 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27309 PyObject *obj;
27310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27311 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27312 return SWIG_Py_Void();
27313 }
27314
27315 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27316 return SWIG_Python_InitShadowInstance(args);
27317 }
27318
27319 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27320 PyObject *resultobj = 0;
27321 long arg1 ;
27322 wxTimeSpan result;
27323 long val1 ;
27324 int ecode1 = 0 ;
27325 PyObject * obj0 = 0 ;
27326 char * kwnames[] = {
27327 (char *) "ms", NULL
27328 };
27329
27330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27331 ecode1 = SWIG_AsVal_long(obj0, &val1);
27332 if (!SWIG_IsOK(ecode1)) {
27333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27334 }
27335 arg1 = static_cast< long >(val1);
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 result = wxTimeSpan::Milliseconds(arg1);
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27350 PyObject *resultobj = 0;
27351 wxTimeSpan result;
27352
27353 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 result = wxTimeSpan::Millisecond();
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27368 PyObject *resultobj = 0;
27369 long arg1 ;
27370 wxTimeSpan result;
27371 long val1 ;
27372 int ecode1 = 0 ;
27373 PyObject * obj0 = 0 ;
27374 char * kwnames[] = {
27375 (char *) "sec", NULL
27376 };
27377
27378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27379 ecode1 = SWIG_AsVal_long(obj0, &val1);
27380 if (!SWIG_IsOK(ecode1)) {
27381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27382 }
27383 arg1 = static_cast< long >(val1);
27384 {
27385 PyThreadState* __tstate = wxPyBeginAllowThreads();
27386 result = wxTimeSpan::Seconds(arg1);
27387 wxPyEndAllowThreads(__tstate);
27388 if (PyErr_Occurred()) SWIG_fail;
27389 }
27390 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27391 return resultobj;
27392 fail:
27393 return NULL;
27394 }
27395
27396
27397 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27398 PyObject *resultobj = 0;
27399 wxTimeSpan result;
27400
27401 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 result = wxTimeSpan::Second();
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27416 PyObject *resultobj = 0;
27417 long arg1 ;
27418 wxTimeSpan result;
27419 long val1 ;
27420 int ecode1 = 0 ;
27421 PyObject * obj0 = 0 ;
27422 char * kwnames[] = {
27423 (char *) "min", NULL
27424 };
27425
27426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27427 ecode1 = SWIG_AsVal_long(obj0, &val1);
27428 if (!SWIG_IsOK(ecode1)) {
27429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27430 }
27431 arg1 = static_cast< long >(val1);
27432 {
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 result = wxTimeSpan::Minutes(arg1);
27435 wxPyEndAllowThreads(__tstate);
27436 if (PyErr_Occurred()) SWIG_fail;
27437 }
27438 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27446 PyObject *resultobj = 0;
27447 wxTimeSpan result;
27448
27449 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27450 {
27451 PyThreadState* __tstate = wxPyBeginAllowThreads();
27452 result = wxTimeSpan::Minute();
27453 wxPyEndAllowThreads(__tstate);
27454 if (PyErr_Occurred()) SWIG_fail;
27455 }
27456 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27457 return resultobj;
27458 fail:
27459 return NULL;
27460 }
27461
27462
27463 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27464 PyObject *resultobj = 0;
27465 long arg1 ;
27466 wxTimeSpan result;
27467 long val1 ;
27468 int ecode1 = 0 ;
27469 PyObject * obj0 = 0 ;
27470 char * kwnames[] = {
27471 (char *) "hours", NULL
27472 };
27473
27474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27475 ecode1 = SWIG_AsVal_long(obj0, &val1);
27476 if (!SWIG_IsOK(ecode1)) {
27477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27478 }
27479 arg1 = static_cast< long >(val1);
27480 {
27481 PyThreadState* __tstate = wxPyBeginAllowThreads();
27482 result = wxTimeSpan::Hours(arg1);
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27487 return resultobj;
27488 fail:
27489 return NULL;
27490 }
27491
27492
27493 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27494 PyObject *resultobj = 0;
27495 wxTimeSpan result;
27496
27497 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 result = wxTimeSpan::Hour();
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj = 0;
27513 long arg1 ;
27514 wxTimeSpan result;
27515 long val1 ;
27516 int ecode1 = 0 ;
27517 PyObject * obj0 = 0 ;
27518 char * kwnames[] = {
27519 (char *) "days", NULL
27520 };
27521
27522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27523 ecode1 = SWIG_AsVal_long(obj0, &val1);
27524 if (!SWIG_IsOK(ecode1)) {
27525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27526 }
27527 arg1 = static_cast< long >(val1);
27528 {
27529 PyThreadState* __tstate = wxPyBeginAllowThreads();
27530 result = wxTimeSpan::Days(arg1);
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27542 PyObject *resultobj = 0;
27543 wxTimeSpan result;
27544
27545 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27546 {
27547 PyThreadState* __tstate = wxPyBeginAllowThreads();
27548 result = wxTimeSpan::Day();
27549 wxPyEndAllowThreads(__tstate);
27550 if (PyErr_Occurred()) SWIG_fail;
27551 }
27552 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27553 return resultobj;
27554 fail:
27555 return NULL;
27556 }
27557
27558
27559 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27560 PyObject *resultobj = 0;
27561 long arg1 ;
27562 wxTimeSpan result;
27563 long val1 ;
27564 int ecode1 = 0 ;
27565 PyObject * obj0 = 0 ;
27566 char * kwnames[] = {
27567 (char *) "days", NULL
27568 };
27569
27570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27571 ecode1 = SWIG_AsVal_long(obj0, &val1);
27572 if (!SWIG_IsOK(ecode1)) {
27573 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27574 }
27575 arg1 = static_cast< long >(val1);
27576 {
27577 PyThreadState* __tstate = wxPyBeginAllowThreads();
27578 result = wxTimeSpan::Weeks(arg1);
27579 wxPyEndAllowThreads(__tstate);
27580 if (PyErr_Occurred()) SWIG_fail;
27581 }
27582 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27590 PyObject *resultobj = 0;
27591 wxTimeSpan result;
27592
27593 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 result = wxTimeSpan::Week();
27597 wxPyEndAllowThreads(__tstate);
27598 if (PyErr_Occurred()) SWIG_fail;
27599 }
27600 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27601 return resultobj;
27602 fail:
27603 return NULL;
27604 }
27605
27606
27607 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27608 PyObject *resultobj = 0;
27609 long arg1 = (long) 0 ;
27610 long arg2 = (long) 0 ;
27611 long arg3 = (long) 0 ;
27612 long arg4 = (long) 0 ;
27613 wxTimeSpan *result = 0 ;
27614 long val1 ;
27615 int ecode1 = 0 ;
27616 long val2 ;
27617 int ecode2 = 0 ;
27618 long val3 ;
27619 int ecode3 = 0 ;
27620 long val4 ;
27621 int ecode4 = 0 ;
27622 PyObject * obj0 = 0 ;
27623 PyObject * obj1 = 0 ;
27624 PyObject * obj2 = 0 ;
27625 PyObject * obj3 = 0 ;
27626 char * kwnames[] = {
27627 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27628 };
27629
27630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27631 if (obj0) {
27632 ecode1 = SWIG_AsVal_long(obj0, &val1);
27633 if (!SWIG_IsOK(ecode1)) {
27634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27635 }
27636 arg1 = static_cast< long >(val1);
27637 }
27638 if (obj1) {
27639 ecode2 = SWIG_AsVal_long(obj1, &val2);
27640 if (!SWIG_IsOK(ecode2)) {
27641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27642 }
27643 arg2 = static_cast< long >(val2);
27644 }
27645 if (obj2) {
27646 ecode3 = SWIG_AsVal_long(obj2, &val3);
27647 if (!SWIG_IsOK(ecode3)) {
27648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27649 }
27650 arg3 = static_cast< long >(val3);
27651 }
27652 if (obj3) {
27653 ecode4 = SWIG_AsVal_long(obj3, &val4);
27654 if (!SWIG_IsOK(ecode4)) {
27655 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27656 }
27657 arg4 = static_cast< long >(val4);
27658 }
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27662 wxPyEndAllowThreads(__tstate);
27663 if (PyErr_Occurred()) SWIG_fail;
27664 }
27665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27666 return resultobj;
27667 fail:
27668 return NULL;
27669 }
27670
27671
27672 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27673 PyObject *resultobj = 0;
27674 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27675 void *argp1 = 0 ;
27676 int res1 = 0 ;
27677 PyObject *swig_obj[1] ;
27678
27679 if (!args) SWIG_fail;
27680 swig_obj[0] = args;
27681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27682 if (!SWIG_IsOK(res1)) {
27683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27684 }
27685 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 delete arg1;
27689
27690 wxPyEndAllowThreads(__tstate);
27691 if (PyErr_Occurred()) SWIG_fail;
27692 }
27693 resultobj = SWIG_Py_Void();
27694 return resultobj;
27695 fail:
27696 return NULL;
27697 }
27698
27699
27700 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27701 PyObject *resultobj = 0;
27702 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27703 wxTimeSpan *arg2 = 0 ;
27704 wxTimeSpan *result = 0 ;
27705 void *argp1 = 0 ;
27706 int res1 = 0 ;
27707 void *argp2 = 0 ;
27708 int res2 = 0 ;
27709 PyObject * obj0 = 0 ;
27710 PyObject * obj1 = 0 ;
27711 char * kwnames[] = {
27712 (char *) "self",(char *) "diff", NULL
27713 };
27714
27715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27717 if (!SWIG_IsOK(res1)) {
27718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27719 }
27720 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27722 if (!SWIG_IsOK(res2)) {
27723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27724 }
27725 if (!argp2) {
27726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27727 }
27728 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27729 {
27730 PyThreadState* __tstate = wxPyBeginAllowThreads();
27731 {
27732 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27733 result = (wxTimeSpan *) &_result_ref;
27734 }
27735 wxPyEndAllowThreads(__tstate);
27736 if (PyErr_Occurred()) SWIG_fail;
27737 }
27738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27746 PyObject *resultobj = 0;
27747 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27748 wxTimeSpan *arg2 = 0 ;
27749 wxTimeSpan *result = 0 ;
27750 void *argp1 = 0 ;
27751 int res1 = 0 ;
27752 void *argp2 = 0 ;
27753 int res2 = 0 ;
27754 PyObject * obj0 = 0 ;
27755 PyObject * obj1 = 0 ;
27756 char * kwnames[] = {
27757 (char *) "self",(char *) "diff", NULL
27758 };
27759
27760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27762 if (!SWIG_IsOK(res1)) {
27763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27764 }
27765 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27766 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27767 if (!SWIG_IsOK(res2)) {
27768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27769 }
27770 if (!argp2) {
27771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27772 }
27773 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27774 {
27775 PyThreadState* __tstate = wxPyBeginAllowThreads();
27776 {
27777 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27778 result = (wxTimeSpan *) &_result_ref;
27779 }
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27784 return resultobj;
27785 fail:
27786 return NULL;
27787 }
27788
27789
27790 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27791 PyObject *resultobj = 0;
27792 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27793 int arg2 ;
27794 wxTimeSpan *result = 0 ;
27795 void *argp1 = 0 ;
27796 int res1 = 0 ;
27797 int val2 ;
27798 int ecode2 = 0 ;
27799 PyObject * obj0 = 0 ;
27800 PyObject * obj1 = 0 ;
27801 char * kwnames[] = {
27802 (char *) "self",(char *) "n", NULL
27803 };
27804
27805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27807 if (!SWIG_IsOK(res1)) {
27808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27809 }
27810 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27811 ecode2 = SWIG_AsVal_int(obj1, &val2);
27812 if (!SWIG_IsOK(ecode2)) {
27813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27814 }
27815 arg2 = static_cast< int >(val2);
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 {
27819 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27820 result = (wxTimeSpan *) &_result_ref;
27821 }
27822 wxPyEndAllowThreads(__tstate);
27823 if (PyErr_Occurred()) SWIG_fail;
27824 }
27825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27833 PyObject *resultobj = 0;
27834 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27835 wxTimeSpan *result = 0 ;
27836 void *argp1 = 0 ;
27837 int res1 = 0 ;
27838 PyObject *swig_obj[1] ;
27839
27840 if (!args) SWIG_fail;
27841 swig_obj[0] = args;
27842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27843 if (!SWIG_IsOK(res1)) {
27844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27845 }
27846 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 {
27850 wxTimeSpan &_result_ref = (arg1)->Neg();
27851 result = (wxTimeSpan *) &_result_ref;
27852 }
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27857 return resultobj;
27858 fail:
27859 return NULL;
27860 }
27861
27862
27863 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27864 PyObject *resultobj = 0;
27865 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27866 wxTimeSpan result;
27867 void *argp1 = 0 ;
27868 int res1 = 0 ;
27869 PyObject *swig_obj[1] ;
27870
27871 if (!args) SWIG_fail;
27872 swig_obj[0] = args;
27873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27874 if (!SWIG_IsOK(res1)) {
27875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27876 }
27877 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27878 {
27879 PyThreadState* __tstate = wxPyBeginAllowThreads();
27880 result = ((wxTimeSpan const *)arg1)->Abs();
27881 wxPyEndAllowThreads(__tstate);
27882 if (PyErr_Occurred()) SWIG_fail;
27883 }
27884 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27885 return resultobj;
27886 fail:
27887 return NULL;
27888 }
27889
27890
27891 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27892 PyObject *resultobj = 0;
27893 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27894 wxTimeSpan *arg2 = 0 ;
27895 wxTimeSpan *result = 0 ;
27896 void *argp1 = 0 ;
27897 int res1 = 0 ;
27898 void *argp2 = 0 ;
27899 int res2 = 0 ;
27900 PyObject * obj0 = 0 ;
27901 PyObject * obj1 = 0 ;
27902 char * kwnames[] = {
27903 (char *) "self",(char *) "diff", NULL
27904 };
27905
27906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27908 if (!SWIG_IsOK(res1)) {
27909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27910 }
27911 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27912 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27913 if (!SWIG_IsOK(res2)) {
27914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27915 }
27916 if (!argp2) {
27917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27918 }
27919 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27920 {
27921 PyThreadState* __tstate = wxPyBeginAllowThreads();
27922 {
27923 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27924 result = (wxTimeSpan *) &_result_ref;
27925 }
27926 wxPyEndAllowThreads(__tstate);
27927 if (PyErr_Occurred()) SWIG_fail;
27928 }
27929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27930 return resultobj;
27931 fail:
27932 return NULL;
27933 }
27934
27935
27936 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27937 PyObject *resultobj = 0;
27938 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27939 wxTimeSpan *arg2 = 0 ;
27940 wxTimeSpan *result = 0 ;
27941 void *argp1 = 0 ;
27942 int res1 = 0 ;
27943 void *argp2 = 0 ;
27944 int res2 = 0 ;
27945 PyObject * obj0 = 0 ;
27946 PyObject * obj1 = 0 ;
27947 char * kwnames[] = {
27948 (char *) "self",(char *) "diff", NULL
27949 };
27950
27951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27953 if (!SWIG_IsOK(res1)) {
27954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27955 }
27956 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27957 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27958 if (!SWIG_IsOK(res2)) {
27959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27960 }
27961 if (!argp2) {
27962 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27963 }
27964 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 {
27968 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27969 result = (wxTimeSpan *) &_result_ref;
27970 }
27971 wxPyEndAllowThreads(__tstate);
27972 if (PyErr_Occurred()) SWIG_fail;
27973 }
27974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27975 return resultobj;
27976 fail:
27977 return NULL;
27978 }
27979
27980
27981 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27982 PyObject *resultobj = 0;
27983 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27984 int arg2 ;
27985 wxTimeSpan *result = 0 ;
27986 void *argp1 = 0 ;
27987 int res1 = 0 ;
27988 int val2 ;
27989 int ecode2 = 0 ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char * kwnames[] = {
27993 (char *) "self",(char *) "n", NULL
27994 };
27995
27996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28000 }
28001 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28002 ecode2 = SWIG_AsVal_int(obj1, &val2);
28003 if (!SWIG_IsOK(ecode2)) {
28004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28005 }
28006 arg2 = static_cast< int >(val2);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 {
28010 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28011 result = (wxTimeSpan *) &_result_ref;
28012 }
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28024 PyObject *resultobj = 0;
28025 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28026 wxTimeSpan *result = 0 ;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 PyObject *swig_obj[1] ;
28030
28031 if (!args) SWIG_fail;
28032 swig_obj[0] = args;
28033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28034 if (!SWIG_IsOK(res1)) {
28035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28036 }
28037 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28038 {
28039 PyThreadState* __tstate = wxPyBeginAllowThreads();
28040 {
28041 wxTimeSpan &_result_ref = (arg1)->operator -();
28042 result = (wxTimeSpan *) &_result_ref;
28043 }
28044 wxPyEndAllowThreads(__tstate);
28045 if (PyErr_Occurred()) SWIG_fail;
28046 }
28047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28048 return resultobj;
28049 fail:
28050 return NULL;
28051 }
28052
28053
28054 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28055 PyObject *resultobj = 0;
28056 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28057 wxTimeSpan *arg2 = 0 ;
28058 wxTimeSpan result;
28059 void *argp1 = 0 ;
28060 int res1 = 0 ;
28061 void *argp2 = 0 ;
28062 int res2 = 0 ;
28063 PyObject * obj0 = 0 ;
28064 PyObject * obj1 = 0 ;
28065 char * kwnames[] = {
28066 (char *) "self",(char *) "other", NULL
28067 };
28068
28069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28071 if (!SWIG_IsOK(res1)) {
28072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28073 }
28074 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28075 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28076 if (!SWIG_IsOK(res2)) {
28077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28078 }
28079 if (!argp2) {
28080 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28081 }
28082 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28090 return resultobj;
28091 fail:
28092 return NULL;
28093 }
28094
28095
28096 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28097 PyObject *resultobj = 0;
28098 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28099 wxTimeSpan *arg2 = 0 ;
28100 wxTimeSpan result;
28101 void *argp1 = 0 ;
28102 int res1 = 0 ;
28103 void *argp2 = 0 ;
28104 int res2 = 0 ;
28105 PyObject * obj0 = 0 ;
28106 PyObject * obj1 = 0 ;
28107 char * kwnames[] = {
28108 (char *) "self",(char *) "other", NULL
28109 };
28110
28111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28113 if (!SWIG_IsOK(res1)) {
28114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28115 }
28116 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28118 if (!SWIG_IsOK(res2)) {
28119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28120 }
28121 if (!argp2) {
28122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28123 }
28124 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28139 PyObject *resultobj = 0;
28140 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28141 int arg2 ;
28142 wxTimeSpan result;
28143 void *argp1 = 0 ;
28144 int res1 = 0 ;
28145 int val2 ;
28146 int ecode2 = 0 ;
28147 PyObject * obj0 = 0 ;
28148 PyObject * obj1 = 0 ;
28149 char * kwnames[] = {
28150 (char *) "self",(char *) "n", NULL
28151 };
28152
28153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28155 if (!SWIG_IsOK(res1)) {
28156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28157 }
28158 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28159 ecode2 = SWIG_AsVal_int(obj1, &val2);
28160 if (!SWIG_IsOK(ecode2)) {
28161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28162 }
28163 arg2 = static_cast< int >(val2);
28164 {
28165 PyThreadState* __tstate = wxPyBeginAllowThreads();
28166 result = wxTimeSpan___mul__(arg1,arg2);
28167 wxPyEndAllowThreads(__tstate);
28168 if (PyErr_Occurred()) SWIG_fail;
28169 }
28170 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28171 return resultobj;
28172 fail:
28173 return NULL;
28174 }
28175
28176
28177 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28178 PyObject *resultobj = 0;
28179 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28180 int arg2 ;
28181 wxTimeSpan result;
28182 void *argp1 = 0 ;
28183 int res1 = 0 ;
28184 int val2 ;
28185 int ecode2 = 0 ;
28186 PyObject * obj0 = 0 ;
28187 PyObject * obj1 = 0 ;
28188 char * kwnames[] = {
28189 (char *) "self",(char *) "n", NULL
28190 };
28191
28192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28194 if (!SWIG_IsOK(res1)) {
28195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28196 }
28197 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28198 ecode2 = SWIG_AsVal_int(obj1, &val2);
28199 if (!SWIG_IsOK(ecode2)) {
28200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28201 }
28202 arg2 = static_cast< int >(val2);
28203 {
28204 PyThreadState* __tstate = wxPyBeginAllowThreads();
28205 result = wxTimeSpan___rmul__(arg1,arg2);
28206 wxPyEndAllowThreads(__tstate);
28207 if (PyErr_Occurred()) SWIG_fail;
28208 }
28209 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28210 return resultobj;
28211 fail:
28212 return NULL;
28213 }
28214
28215
28216 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28217 PyObject *resultobj = 0;
28218 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28219 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28220 bool result;
28221 void *argp1 = 0 ;
28222 int res1 = 0 ;
28223 void *argp2 = 0 ;
28224 int res2 = 0 ;
28225 PyObject * obj0 = 0 ;
28226 PyObject * obj1 = 0 ;
28227 char * kwnames[] = {
28228 (char *) "self",(char *) "other", NULL
28229 };
28230
28231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28233 if (!SWIG_IsOK(res1)) {
28234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28235 }
28236 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28237 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28238 if (!SWIG_IsOK(res2)) {
28239 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28240 }
28241 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 {
28249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28250 }
28251 return resultobj;
28252 fail:
28253 return NULL;
28254 }
28255
28256
28257 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28258 PyObject *resultobj = 0;
28259 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28260 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28261 bool result;
28262 void *argp1 = 0 ;
28263 int res1 = 0 ;
28264 void *argp2 = 0 ;
28265 int res2 = 0 ;
28266 PyObject * obj0 = 0 ;
28267 PyObject * obj1 = 0 ;
28268 char * kwnames[] = {
28269 (char *) "self",(char *) "other", NULL
28270 };
28271
28272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28274 if (!SWIG_IsOK(res1)) {
28275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28276 }
28277 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28279 if (!SWIG_IsOK(res2)) {
28280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28281 }
28282 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 {
28290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28291 }
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28299 PyObject *resultobj = 0;
28300 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28301 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28302 bool result;
28303 void *argp1 = 0 ;
28304 int res1 = 0 ;
28305 void *argp2 = 0 ;
28306 int res2 = 0 ;
28307 PyObject * obj0 = 0 ;
28308 PyObject * obj1 = 0 ;
28309 char * kwnames[] = {
28310 (char *) "self",(char *) "other", NULL
28311 };
28312
28313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28315 if (!SWIG_IsOK(res1)) {
28316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28317 }
28318 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28320 if (!SWIG_IsOK(res2)) {
28321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28322 }
28323 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28324 {
28325 PyThreadState* __tstate = wxPyBeginAllowThreads();
28326 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28327 wxPyEndAllowThreads(__tstate);
28328 if (PyErr_Occurred()) SWIG_fail;
28329 }
28330 {
28331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28332 }
28333 return resultobj;
28334 fail:
28335 return NULL;
28336 }
28337
28338
28339 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28340 PyObject *resultobj = 0;
28341 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28342 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28343 bool result;
28344 void *argp1 = 0 ;
28345 int res1 = 0 ;
28346 void *argp2 = 0 ;
28347 int res2 = 0 ;
28348 PyObject * obj0 = 0 ;
28349 PyObject * obj1 = 0 ;
28350 char * kwnames[] = {
28351 (char *) "self",(char *) "other", NULL
28352 };
28353
28354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28356 if (!SWIG_IsOK(res1)) {
28357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28358 }
28359 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28361 if (!SWIG_IsOK(res2)) {
28362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28363 }
28364 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 {
28372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28373 }
28374 return resultobj;
28375 fail:
28376 return NULL;
28377 }
28378
28379
28380 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28381 PyObject *resultobj = 0;
28382 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28383 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28384 bool result;
28385 void *argp1 = 0 ;
28386 int res1 = 0 ;
28387 void *argp2 = 0 ;
28388 int res2 = 0 ;
28389 PyObject * obj0 = 0 ;
28390 PyObject * obj1 = 0 ;
28391 char * kwnames[] = {
28392 (char *) "self",(char *) "other", NULL
28393 };
28394
28395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28397 if (!SWIG_IsOK(res1)) {
28398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28399 }
28400 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28402 if (!SWIG_IsOK(res2)) {
28403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28404 }
28405 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28406 {
28407 PyThreadState* __tstate = wxPyBeginAllowThreads();
28408 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28409 wxPyEndAllowThreads(__tstate);
28410 if (PyErr_Occurred()) SWIG_fail;
28411 }
28412 {
28413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28414 }
28415 return resultobj;
28416 fail:
28417 return NULL;
28418 }
28419
28420
28421 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28422 PyObject *resultobj = 0;
28423 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28424 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28425 bool result;
28426 void *argp1 = 0 ;
28427 int res1 = 0 ;
28428 void *argp2 = 0 ;
28429 int res2 = 0 ;
28430 PyObject * obj0 = 0 ;
28431 PyObject * obj1 = 0 ;
28432 char * kwnames[] = {
28433 (char *) "self",(char *) "other", NULL
28434 };
28435
28436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28438 if (!SWIG_IsOK(res1)) {
28439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28440 }
28441 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28443 if (!SWIG_IsOK(res2)) {
28444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28445 }
28446 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28447 {
28448 PyThreadState* __tstate = wxPyBeginAllowThreads();
28449 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28450 wxPyEndAllowThreads(__tstate);
28451 if (PyErr_Occurred()) SWIG_fail;
28452 }
28453 {
28454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28455 }
28456 return resultobj;
28457 fail:
28458 return NULL;
28459 }
28460
28461
28462 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28463 PyObject *resultobj = 0;
28464 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28465 bool result;
28466 void *argp1 = 0 ;
28467 int res1 = 0 ;
28468 PyObject *swig_obj[1] ;
28469
28470 if (!args) SWIG_fail;
28471 swig_obj[0] = args;
28472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28473 if (!SWIG_IsOK(res1)) {
28474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28475 }
28476 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28480 wxPyEndAllowThreads(__tstate);
28481 if (PyErr_Occurred()) SWIG_fail;
28482 }
28483 {
28484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28485 }
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28493 PyObject *resultobj = 0;
28494 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28495 bool result;
28496 void *argp1 = 0 ;
28497 int res1 = 0 ;
28498 PyObject *swig_obj[1] ;
28499
28500 if (!args) SWIG_fail;
28501 swig_obj[0] = args;
28502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28503 if (!SWIG_IsOK(res1)) {
28504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28505 }
28506 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28507 {
28508 PyThreadState* __tstate = wxPyBeginAllowThreads();
28509 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28510 wxPyEndAllowThreads(__tstate);
28511 if (PyErr_Occurred()) SWIG_fail;
28512 }
28513 {
28514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28515 }
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28523 PyObject *resultobj = 0;
28524 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28525 bool result;
28526 void *argp1 = 0 ;
28527 int res1 = 0 ;
28528 PyObject *swig_obj[1] ;
28529
28530 if (!args) SWIG_fail;
28531 swig_obj[0] = args;
28532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28533 if (!SWIG_IsOK(res1)) {
28534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28535 }
28536 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 {
28544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28545 }
28546 return resultobj;
28547 fail:
28548 return NULL;
28549 }
28550
28551
28552 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28553 PyObject *resultobj = 0;
28554 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28555 wxTimeSpan *arg2 = 0 ;
28556 bool result;
28557 void *argp1 = 0 ;
28558 int res1 = 0 ;
28559 void *argp2 = 0 ;
28560 int res2 = 0 ;
28561 PyObject * obj0 = 0 ;
28562 PyObject * obj1 = 0 ;
28563 char * kwnames[] = {
28564 (char *) "self",(char *) "ts", NULL
28565 };
28566
28567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28569 if (!SWIG_IsOK(res1)) {
28570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28571 }
28572 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28573 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28574 if (!SWIG_IsOK(res2)) {
28575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28576 }
28577 if (!argp2) {
28578 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28579 }
28580 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28581 {
28582 PyThreadState* __tstate = wxPyBeginAllowThreads();
28583 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28584 wxPyEndAllowThreads(__tstate);
28585 if (PyErr_Occurred()) SWIG_fail;
28586 }
28587 {
28588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28589 }
28590 return resultobj;
28591 fail:
28592 return NULL;
28593 }
28594
28595
28596 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28597 PyObject *resultobj = 0;
28598 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28599 wxTimeSpan *arg2 = 0 ;
28600 bool result;
28601 void *argp1 = 0 ;
28602 int res1 = 0 ;
28603 void *argp2 = 0 ;
28604 int res2 = 0 ;
28605 PyObject * obj0 = 0 ;
28606 PyObject * obj1 = 0 ;
28607 char * kwnames[] = {
28608 (char *) "self",(char *) "ts", NULL
28609 };
28610
28611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28613 if (!SWIG_IsOK(res1)) {
28614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28615 }
28616 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28617 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28618 if (!SWIG_IsOK(res2)) {
28619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28620 }
28621 if (!argp2) {
28622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28623 }
28624 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 {
28632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28633 }
28634 return resultobj;
28635 fail:
28636 return NULL;
28637 }
28638
28639
28640 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28641 PyObject *resultobj = 0;
28642 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28643 wxTimeSpan *arg2 = 0 ;
28644 bool result;
28645 void *argp1 = 0 ;
28646 int res1 = 0 ;
28647 void *argp2 = 0 ;
28648 int res2 = 0 ;
28649 PyObject * obj0 = 0 ;
28650 PyObject * obj1 = 0 ;
28651 char * kwnames[] = {
28652 (char *) "self",(char *) "t", NULL
28653 };
28654
28655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28657 if (!SWIG_IsOK(res1)) {
28658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28659 }
28660 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28661 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28662 if (!SWIG_IsOK(res2)) {
28663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28664 }
28665 if (!argp2) {
28666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28667 }
28668 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 {
28676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28677 }
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28685 PyObject *resultobj = 0;
28686 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28687 int result;
28688 void *argp1 = 0 ;
28689 int res1 = 0 ;
28690 PyObject *swig_obj[1] ;
28691
28692 if (!args) SWIG_fail;
28693 swig_obj[0] = args;
28694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28695 if (!SWIG_IsOK(res1)) {
28696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28697 }
28698 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 resultobj = SWIG_From_int(static_cast< int >(result));
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28713 PyObject *resultobj = 0;
28714 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28715 int result;
28716 void *argp1 = 0 ;
28717 int res1 = 0 ;
28718 PyObject *swig_obj[1] ;
28719
28720 if (!args) SWIG_fail;
28721 swig_obj[0] = args;
28722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28723 if (!SWIG_IsOK(res1)) {
28724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28725 }
28726 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 resultobj = SWIG_From_int(static_cast< int >(result));
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741 PyObject *resultobj = 0;
28742 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28743 int result;
28744 void *argp1 = 0 ;
28745 int res1 = 0 ;
28746 PyObject *swig_obj[1] ;
28747
28748 if (!args) SWIG_fail;
28749 swig_obj[0] = args;
28750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28751 if (!SWIG_IsOK(res1)) {
28752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28753 }
28754 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28755 {
28756 PyThreadState* __tstate = wxPyBeginAllowThreads();
28757 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28758 wxPyEndAllowThreads(__tstate);
28759 if (PyErr_Occurred()) SWIG_fail;
28760 }
28761 resultobj = SWIG_From_int(static_cast< int >(result));
28762 return resultobj;
28763 fail:
28764 return NULL;
28765 }
28766
28767
28768 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28769 PyObject *resultobj = 0;
28770 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28771 int result;
28772 void *argp1 = 0 ;
28773 int res1 = 0 ;
28774 PyObject *swig_obj[1] ;
28775
28776 if (!args) SWIG_fail;
28777 swig_obj[0] = args;
28778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28779 if (!SWIG_IsOK(res1)) {
28780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28781 }
28782 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_From_int(static_cast< int >(result));
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28797 PyObject *resultobj = 0;
28798 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28799 wxLongLong result;
28800 void *argp1 = 0 ;
28801 int res1 = 0 ;
28802 PyObject *swig_obj[1] ;
28803
28804 if (!args) SWIG_fail;
28805 swig_obj[0] = args;
28806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28807 if (!SWIG_IsOK(res1)) {
28808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28809 }
28810 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 PyObject *hi, *lo, *shifter, *shifted;
28819 hi = PyLong_FromLong( (&result)->GetHi() );
28820 lo = PyLong_FromLong( (&result)->GetLo() );
28821 shifter = PyLong_FromLong(32);
28822 shifted = PyNumber_Lshift(hi, shifter);
28823 resultobj = PyNumber_Or(shifted, lo);
28824 Py_DECREF(hi);
28825 Py_DECREF(lo);
28826 Py_DECREF(shifter);
28827 Py_DECREF(shifted);
28828 }
28829 return resultobj;
28830 fail:
28831 return NULL;
28832 }
28833
28834
28835 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28836 PyObject *resultobj = 0;
28837 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28838 wxLongLong result;
28839 void *argp1 = 0 ;
28840 int res1 = 0 ;
28841 PyObject *swig_obj[1] ;
28842
28843 if (!args) SWIG_fail;
28844 swig_obj[0] = args;
28845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28846 if (!SWIG_IsOK(res1)) {
28847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28848 }
28849 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28850 {
28851 PyThreadState* __tstate = wxPyBeginAllowThreads();
28852 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 {
28857 PyObject *hi, *lo, *shifter, *shifted;
28858 hi = PyLong_FromLong( (&result)->GetHi() );
28859 lo = PyLong_FromLong( (&result)->GetLo() );
28860 shifter = PyLong_FromLong(32);
28861 shifted = PyNumber_Lshift(hi, shifter);
28862 resultobj = PyNumber_Or(shifted, lo);
28863 Py_DECREF(hi);
28864 Py_DECREF(lo);
28865 Py_DECREF(shifter);
28866 Py_DECREF(shifted);
28867 }
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28875 PyObject *resultobj = 0;
28876 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28877 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28878 wxString *arg2 = (wxString *) &arg2_defvalue ;
28879 wxString result;
28880 void *argp1 = 0 ;
28881 int res1 = 0 ;
28882 bool temp2 = false ;
28883 PyObject * obj0 = 0 ;
28884 PyObject * obj1 = 0 ;
28885 char * kwnames[] = {
28886 (char *) "self",(char *) "format", NULL
28887 };
28888
28889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28891 if (!SWIG_IsOK(res1)) {
28892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28893 }
28894 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28895 if (obj1) {
28896 {
28897 arg2 = wxString_in_helper(obj1);
28898 if (arg2 == NULL) SWIG_fail;
28899 temp2 = true;
28900 }
28901 }
28902 {
28903 PyThreadState* __tstate = wxPyBeginAllowThreads();
28904 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 {
28909 #if wxUSE_UNICODE
28910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28911 #else
28912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28913 #endif
28914 }
28915 {
28916 if (temp2)
28917 delete arg2;
28918 }
28919 return resultobj;
28920 fail:
28921 {
28922 if (temp2)
28923 delete arg2;
28924 }
28925 return NULL;
28926 }
28927
28928
28929 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28930 PyObject *obj;
28931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28932 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28933 return SWIG_Py_Void();
28934 }
28935
28936 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28937 return SWIG_Python_InitShadowInstance(args);
28938 }
28939
28940 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28941 PyObject *resultobj = 0;
28942 int arg1 = (int) 0 ;
28943 int arg2 = (int) 0 ;
28944 int arg3 = (int) 0 ;
28945 int arg4 = (int) 0 ;
28946 wxDateSpan *result = 0 ;
28947 int val1 ;
28948 int ecode1 = 0 ;
28949 int val2 ;
28950 int ecode2 = 0 ;
28951 int val3 ;
28952 int ecode3 = 0 ;
28953 int val4 ;
28954 int ecode4 = 0 ;
28955 PyObject * obj0 = 0 ;
28956 PyObject * obj1 = 0 ;
28957 PyObject * obj2 = 0 ;
28958 PyObject * obj3 = 0 ;
28959 char * kwnames[] = {
28960 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28961 };
28962
28963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28964 if (obj0) {
28965 ecode1 = SWIG_AsVal_int(obj0, &val1);
28966 if (!SWIG_IsOK(ecode1)) {
28967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28968 }
28969 arg1 = static_cast< int >(val1);
28970 }
28971 if (obj1) {
28972 ecode2 = SWIG_AsVal_int(obj1, &val2);
28973 if (!SWIG_IsOK(ecode2)) {
28974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28975 }
28976 arg2 = static_cast< int >(val2);
28977 }
28978 if (obj2) {
28979 ecode3 = SWIG_AsVal_int(obj2, &val3);
28980 if (!SWIG_IsOK(ecode3)) {
28981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28982 }
28983 arg3 = static_cast< int >(val3);
28984 }
28985 if (obj3) {
28986 ecode4 = SWIG_AsVal_int(obj3, &val4);
28987 if (!SWIG_IsOK(ecode4)) {
28988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28989 }
28990 arg4 = static_cast< int >(val4);
28991 }
28992 {
28993 PyThreadState* __tstate = wxPyBeginAllowThreads();
28994 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29006 PyObject *resultobj = 0;
29007 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29008 void *argp1 = 0 ;
29009 int res1 = 0 ;
29010 PyObject *swig_obj[1] ;
29011
29012 if (!args) SWIG_fail;
29013 swig_obj[0] = args;
29014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29015 if (!SWIG_IsOK(res1)) {
29016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29017 }
29018 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 delete arg1;
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 resultobj = SWIG_Py_Void();
29027 return resultobj;
29028 fail:
29029 return NULL;
29030 }
29031
29032
29033 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29034 PyObject *resultobj = 0;
29035 int arg1 ;
29036 wxDateSpan result;
29037 int val1 ;
29038 int ecode1 = 0 ;
29039 PyObject * obj0 = 0 ;
29040 char * kwnames[] = {
29041 (char *) "days", NULL
29042 };
29043
29044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29045 ecode1 = SWIG_AsVal_int(obj0, &val1);
29046 if (!SWIG_IsOK(ecode1)) {
29047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29048 }
29049 arg1 = static_cast< int >(val1);
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = wxDateSpan::Days(arg1);
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29057 return resultobj;
29058 fail:
29059 return NULL;
29060 }
29061
29062
29063 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29064 PyObject *resultobj = 0;
29065 wxDateSpan result;
29066
29067 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 result = wxDateSpan::Day();
29071 wxPyEndAllowThreads(__tstate);
29072 if (PyErr_Occurred()) SWIG_fail;
29073 }
29074 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29075 return resultobj;
29076 fail:
29077 return NULL;
29078 }
29079
29080
29081 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29082 PyObject *resultobj = 0;
29083 int arg1 ;
29084 wxDateSpan result;
29085 int val1 ;
29086 int ecode1 = 0 ;
29087 PyObject * obj0 = 0 ;
29088 char * kwnames[] = {
29089 (char *) "weeks", NULL
29090 };
29091
29092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29093 ecode1 = SWIG_AsVal_int(obj0, &val1);
29094 if (!SWIG_IsOK(ecode1)) {
29095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29096 }
29097 arg1 = static_cast< int >(val1);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = wxDateSpan::Weeks(arg1);
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29112 PyObject *resultobj = 0;
29113 wxDateSpan result;
29114
29115 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29116 {
29117 PyThreadState* __tstate = wxPyBeginAllowThreads();
29118 result = wxDateSpan::Week();
29119 wxPyEndAllowThreads(__tstate);
29120 if (PyErr_Occurred()) SWIG_fail;
29121 }
29122 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29123 return resultobj;
29124 fail:
29125 return NULL;
29126 }
29127
29128
29129 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29130 PyObject *resultobj = 0;
29131 int arg1 ;
29132 wxDateSpan result;
29133 int val1 ;
29134 int ecode1 = 0 ;
29135 PyObject * obj0 = 0 ;
29136 char * kwnames[] = {
29137 (char *) "mon", NULL
29138 };
29139
29140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29141 ecode1 = SWIG_AsVal_int(obj0, &val1);
29142 if (!SWIG_IsOK(ecode1)) {
29143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29144 }
29145 arg1 = static_cast< int >(val1);
29146 {
29147 PyThreadState* __tstate = wxPyBeginAllowThreads();
29148 result = wxDateSpan::Months(arg1);
29149 wxPyEndAllowThreads(__tstate);
29150 if (PyErr_Occurred()) SWIG_fail;
29151 }
29152 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29153 return resultobj;
29154 fail:
29155 return NULL;
29156 }
29157
29158
29159 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29160 PyObject *resultobj = 0;
29161 wxDateSpan result;
29162
29163 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29164 {
29165 PyThreadState* __tstate = wxPyBeginAllowThreads();
29166 result = wxDateSpan::Month();
29167 wxPyEndAllowThreads(__tstate);
29168 if (PyErr_Occurred()) SWIG_fail;
29169 }
29170 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29171 return resultobj;
29172 fail:
29173 return NULL;
29174 }
29175
29176
29177 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29178 PyObject *resultobj = 0;
29179 int arg1 ;
29180 wxDateSpan result;
29181 int val1 ;
29182 int ecode1 = 0 ;
29183 PyObject * obj0 = 0 ;
29184 char * kwnames[] = {
29185 (char *) "years", NULL
29186 };
29187
29188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29189 ecode1 = SWIG_AsVal_int(obj0, &val1);
29190 if (!SWIG_IsOK(ecode1)) {
29191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29192 }
29193 arg1 = static_cast< int >(val1);
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 result = wxDateSpan::Years(arg1);
29197 wxPyEndAllowThreads(__tstate);
29198 if (PyErr_Occurred()) SWIG_fail;
29199 }
29200 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29201 return resultobj;
29202 fail:
29203 return NULL;
29204 }
29205
29206
29207 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29208 PyObject *resultobj = 0;
29209 wxDateSpan result;
29210
29211 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29212 {
29213 PyThreadState* __tstate = wxPyBeginAllowThreads();
29214 result = wxDateSpan::Year();
29215 wxPyEndAllowThreads(__tstate);
29216 if (PyErr_Occurred()) SWIG_fail;
29217 }
29218 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29219 return resultobj;
29220 fail:
29221 return NULL;
29222 }
29223
29224
29225 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29226 PyObject *resultobj = 0;
29227 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29228 int arg2 ;
29229 wxDateSpan *result = 0 ;
29230 void *argp1 = 0 ;
29231 int res1 = 0 ;
29232 int val2 ;
29233 int ecode2 = 0 ;
29234 PyObject * obj0 = 0 ;
29235 PyObject * obj1 = 0 ;
29236 char * kwnames[] = {
29237 (char *) "self",(char *) "n", NULL
29238 };
29239
29240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29242 if (!SWIG_IsOK(res1)) {
29243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29244 }
29245 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29246 ecode2 = SWIG_AsVal_int(obj1, &val2);
29247 if (!SWIG_IsOK(ecode2)) {
29248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29249 }
29250 arg2 = static_cast< int >(val2);
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 {
29254 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29255 result = (wxDateSpan *) &_result_ref;
29256 }
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj = 0;
29269 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29270 int arg2 ;
29271 wxDateSpan *result = 0 ;
29272 void *argp1 = 0 ;
29273 int res1 = 0 ;
29274 int val2 ;
29275 int ecode2 = 0 ;
29276 PyObject * obj0 = 0 ;
29277 PyObject * obj1 = 0 ;
29278 char * kwnames[] = {
29279 (char *) "self",(char *) "n", NULL
29280 };
29281
29282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29284 if (!SWIG_IsOK(res1)) {
29285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29286 }
29287 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29288 ecode2 = SWIG_AsVal_int(obj1, &val2);
29289 if (!SWIG_IsOK(ecode2)) {
29290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29291 }
29292 arg2 = static_cast< int >(val2);
29293 {
29294 PyThreadState* __tstate = wxPyBeginAllowThreads();
29295 {
29296 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29297 result = (wxDateSpan *) &_result_ref;
29298 }
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29310 PyObject *resultobj = 0;
29311 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29312 int arg2 ;
29313 wxDateSpan *result = 0 ;
29314 void *argp1 = 0 ;
29315 int res1 = 0 ;
29316 int val2 ;
29317 int ecode2 = 0 ;
29318 PyObject * obj0 = 0 ;
29319 PyObject * obj1 = 0 ;
29320 char * kwnames[] = {
29321 (char *) "self",(char *) "n", NULL
29322 };
29323
29324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29328 }
29329 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29330 ecode2 = SWIG_AsVal_int(obj1, &val2);
29331 if (!SWIG_IsOK(ecode2)) {
29332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29333 }
29334 arg2 = static_cast< int >(val2);
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 {
29338 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29339 result = (wxDateSpan *) &_result_ref;
29340 }
29341 wxPyEndAllowThreads(__tstate);
29342 if (PyErr_Occurred()) SWIG_fail;
29343 }
29344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29352 PyObject *resultobj = 0;
29353 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29354 int arg2 ;
29355 wxDateSpan *result = 0 ;
29356 void *argp1 = 0 ;
29357 int res1 = 0 ;
29358 int val2 ;
29359 int ecode2 = 0 ;
29360 PyObject * obj0 = 0 ;
29361 PyObject * obj1 = 0 ;
29362 char * kwnames[] = {
29363 (char *) "self",(char *) "n", NULL
29364 };
29365
29366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29368 if (!SWIG_IsOK(res1)) {
29369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29370 }
29371 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29372 ecode2 = SWIG_AsVal_int(obj1, &val2);
29373 if (!SWIG_IsOK(ecode2)) {
29374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29375 }
29376 arg2 = static_cast< int >(val2);
29377 {
29378 PyThreadState* __tstate = wxPyBeginAllowThreads();
29379 {
29380 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29381 result = (wxDateSpan *) &_result_ref;
29382 }
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29394 PyObject *resultobj = 0;
29395 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29396 int result;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 PyObject *swig_obj[1] ;
29400
29401 if (!args) SWIG_fail;
29402 swig_obj[0] = args;
29403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29404 if (!SWIG_IsOK(res1)) {
29405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29406 }
29407 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29408 {
29409 PyThreadState* __tstate = wxPyBeginAllowThreads();
29410 result = (int)((wxDateSpan const *)arg1)->GetYears();
29411 wxPyEndAllowThreads(__tstate);
29412 if (PyErr_Occurred()) SWIG_fail;
29413 }
29414 resultobj = SWIG_From_int(static_cast< int >(result));
29415 return resultobj;
29416 fail:
29417 return NULL;
29418 }
29419
29420
29421 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29422 PyObject *resultobj = 0;
29423 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29424 int result;
29425 void *argp1 = 0 ;
29426 int res1 = 0 ;
29427 PyObject *swig_obj[1] ;
29428
29429 if (!args) SWIG_fail;
29430 swig_obj[0] = args;
29431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29432 if (!SWIG_IsOK(res1)) {
29433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29434 }
29435 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29436 {
29437 PyThreadState* __tstate = wxPyBeginAllowThreads();
29438 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 resultobj = SWIG_From_int(static_cast< int >(result));
29443 return resultobj;
29444 fail:
29445 return NULL;
29446 }
29447
29448
29449 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29450 PyObject *resultobj = 0;
29451 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29452 int result;
29453 void *argp1 = 0 ;
29454 int res1 = 0 ;
29455 PyObject *swig_obj[1] ;
29456
29457 if (!args) SWIG_fail;
29458 swig_obj[0] = args;
29459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29460 if (!SWIG_IsOK(res1)) {
29461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29462 }
29463 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29464 {
29465 PyThreadState* __tstate = wxPyBeginAllowThreads();
29466 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29467 wxPyEndAllowThreads(__tstate);
29468 if (PyErr_Occurred()) SWIG_fail;
29469 }
29470 resultobj = SWIG_From_int(static_cast< int >(result));
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29478 PyObject *resultobj = 0;
29479 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29480 int result;
29481 void *argp1 = 0 ;
29482 int res1 = 0 ;
29483 PyObject *swig_obj[1] ;
29484
29485 if (!args) SWIG_fail;
29486 swig_obj[0] = args;
29487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29488 if (!SWIG_IsOK(res1)) {
29489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29490 }
29491 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29492 {
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 result = (int)((wxDateSpan const *)arg1)->GetDays();
29495 wxPyEndAllowThreads(__tstate);
29496 if (PyErr_Occurred()) SWIG_fail;
29497 }
29498 resultobj = SWIG_From_int(static_cast< int >(result));
29499 return resultobj;
29500 fail:
29501 return NULL;
29502 }
29503
29504
29505 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29506 PyObject *resultobj = 0;
29507 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29508 int result;
29509 void *argp1 = 0 ;
29510 int res1 = 0 ;
29511 PyObject *swig_obj[1] ;
29512
29513 if (!args) SWIG_fail;
29514 swig_obj[0] = args;
29515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29516 if (!SWIG_IsOK(res1)) {
29517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29518 }
29519 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29520 {
29521 PyThreadState* __tstate = wxPyBeginAllowThreads();
29522 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29523 wxPyEndAllowThreads(__tstate);
29524 if (PyErr_Occurred()) SWIG_fail;
29525 }
29526 resultobj = SWIG_From_int(static_cast< int >(result));
29527 return resultobj;
29528 fail:
29529 return NULL;
29530 }
29531
29532
29533 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29534 PyObject *resultobj = 0;
29535 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29536 wxDateSpan *arg2 = 0 ;
29537 wxDateSpan *result = 0 ;
29538 void *argp1 = 0 ;
29539 int res1 = 0 ;
29540 void *argp2 = 0 ;
29541 int res2 = 0 ;
29542 PyObject * obj0 = 0 ;
29543 PyObject * obj1 = 0 ;
29544 char * kwnames[] = {
29545 (char *) "self",(char *) "other", NULL
29546 };
29547
29548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29550 if (!SWIG_IsOK(res1)) {
29551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29552 }
29553 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29554 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29555 if (!SWIG_IsOK(res2)) {
29556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29557 }
29558 if (!argp2) {
29559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29560 }
29561 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29562 {
29563 PyThreadState* __tstate = wxPyBeginAllowThreads();
29564 {
29565 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29566 result = (wxDateSpan *) &_result_ref;
29567 }
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29572 return resultobj;
29573 fail:
29574 return NULL;
29575 }
29576
29577
29578 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29579 PyObject *resultobj = 0;
29580 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29581 wxDateSpan *arg2 = 0 ;
29582 wxDateSpan *result = 0 ;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 void *argp2 = 0 ;
29586 int res2 = 0 ;
29587 PyObject * obj0 = 0 ;
29588 PyObject * obj1 = 0 ;
29589 char * kwnames[] = {
29590 (char *) "self",(char *) "other", NULL
29591 };
29592
29593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29595 if (!SWIG_IsOK(res1)) {
29596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29597 }
29598 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29599 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29600 if (!SWIG_IsOK(res2)) {
29601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29602 }
29603 if (!argp2) {
29604 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29605 }
29606 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 {
29610 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29611 result = (wxDateSpan *) &_result_ref;
29612 }
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29624 PyObject *resultobj = 0;
29625 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29626 wxDateSpan *result = 0 ;
29627 void *argp1 = 0 ;
29628 int res1 = 0 ;
29629 PyObject *swig_obj[1] ;
29630
29631 if (!args) SWIG_fail;
29632 swig_obj[0] = args;
29633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29634 if (!SWIG_IsOK(res1)) {
29635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29636 }
29637 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29638 {
29639 PyThreadState* __tstate = wxPyBeginAllowThreads();
29640 {
29641 wxDateSpan &_result_ref = (arg1)->Neg();
29642 result = (wxDateSpan *) &_result_ref;
29643 }
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29648 return resultobj;
29649 fail:
29650 return NULL;
29651 }
29652
29653
29654 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29655 PyObject *resultobj = 0;
29656 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29657 int arg2 ;
29658 wxDateSpan *result = 0 ;
29659 void *argp1 = 0 ;
29660 int res1 = 0 ;
29661 int val2 ;
29662 int ecode2 = 0 ;
29663 PyObject * obj0 = 0 ;
29664 PyObject * obj1 = 0 ;
29665 char * kwnames[] = {
29666 (char *) "self",(char *) "factor", NULL
29667 };
29668
29669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29671 if (!SWIG_IsOK(res1)) {
29672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29673 }
29674 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29675 ecode2 = SWIG_AsVal_int(obj1, &val2);
29676 if (!SWIG_IsOK(ecode2)) {
29677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29678 }
29679 arg2 = static_cast< int >(val2);
29680 {
29681 PyThreadState* __tstate = wxPyBeginAllowThreads();
29682 {
29683 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29684 result = (wxDateSpan *) &_result_ref;
29685 }
29686 wxPyEndAllowThreads(__tstate);
29687 if (PyErr_Occurred()) SWIG_fail;
29688 }
29689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29690 return resultobj;
29691 fail:
29692 return NULL;
29693 }
29694
29695
29696 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29697 PyObject *resultobj = 0;
29698 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29699 wxDateSpan *arg2 = 0 ;
29700 wxDateSpan *result = 0 ;
29701 void *argp1 = 0 ;
29702 int res1 = 0 ;
29703 void *argp2 = 0 ;
29704 int res2 = 0 ;
29705 PyObject * obj0 = 0 ;
29706 PyObject * obj1 = 0 ;
29707 char * kwnames[] = {
29708 (char *) "self",(char *) "other", NULL
29709 };
29710
29711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29713 if (!SWIG_IsOK(res1)) {
29714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29715 }
29716 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29718 if (!SWIG_IsOK(res2)) {
29719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29720 }
29721 if (!argp2) {
29722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29723 }
29724 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29725 {
29726 PyThreadState* __tstate = wxPyBeginAllowThreads();
29727 {
29728 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29729 result = (wxDateSpan *) &_result_ref;
29730 }
29731 wxPyEndAllowThreads(__tstate);
29732 if (PyErr_Occurred()) SWIG_fail;
29733 }
29734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29735 return resultobj;
29736 fail:
29737 return NULL;
29738 }
29739
29740
29741 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29742 PyObject *resultobj = 0;
29743 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29744 wxDateSpan *arg2 = 0 ;
29745 wxDateSpan *result = 0 ;
29746 void *argp1 = 0 ;
29747 int res1 = 0 ;
29748 void *argp2 = 0 ;
29749 int res2 = 0 ;
29750 PyObject * obj0 = 0 ;
29751 PyObject * obj1 = 0 ;
29752 char * kwnames[] = {
29753 (char *) "self",(char *) "other", NULL
29754 };
29755
29756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29758 if (!SWIG_IsOK(res1)) {
29759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29760 }
29761 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29763 if (!SWIG_IsOK(res2)) {
29764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29765 }
29766 if (!argp2) {
29767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29768 }
29769 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29770 {
29771 PyThreadState* __tstate = wxPyBeginAllowThreads();
29772 {
29773 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29774 result = (wxDateSpan *) &_result_ref;
29775 }
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29787 PyObject *resultobj = 0;
29788 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29789 wxDateSpan *result = 0 ;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 PyObject *swig_obj[1] ;
29793
29794 if (!args) SWIG_fail;
29795 swig_obj[0] = args;
29796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29797 if (!SWIG_IsOK(res1)) {
29798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29799 }
29800 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 {
29804 wxDateSpan &_result_ref = (arg1)->operator -();
29805 result = (wxDateSpan *) &_result_ref;
29806 }
29807 wxPyEndAllowThreads(__tstate);
29808 if (PyErr_Occurred()) SWIG_fail;
29809 }
29810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29811 return resultobj;
29812 fail:
29813 return NULL;
29814 }
29815
29816
29817 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29818 PyObject *resultobj = 0;
29819 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29820 int arg2 ;
29821 wxDateSpan *result = 0 ;
29822 void *argp1 = 0 ;
29823 int res1 = 0 ;
29824 int val2 ;
29825 int ecode2 = 0 ;
29826 PyObject * obj0 = 0 ;
29827 PyObject * obj1 = 0 ;
29828 char * kwnames[] = {
29829 (char *) "self",(char *) "factor", NULL
29830 };
29831
29832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29834 if (!SWIG_IsOK(res1)) {
29835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29836 }
29837 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29838 ecode2 = SWIG_AsVal_int(obj1, &val2);
29839 if (!SWIG_IsOK(ecode2)) {
29840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29841 }
29842 arg2 = static_cast< int >(val2);
29843 {
29844 PyThreadState* __tstate = wxPyBeginAllowThreads();
29845 {
29846 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29847 result = (wxDateSpan *) &_result_ref;
29848 }
29849 wxPyEndAllowThreads(__tstate);
29850 if (PyErr_Occurred()) SWIG_fail;
29851 }
29852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29853 return resultobj;
29854 fail:
29855 return NULL;
29856 }
29857
29858
29859 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29860 PyObject *resultobj = 0;
29861 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29862 wxDateSpan *arg2 = 0 ;
29863 wxDateSpan result;
29864 void *argp1 = 0 ;
29865 int res1 = 0 ;
29866 void *argp2 = 0 ;
29867 int res2 = 0 ;
29868 PyObject * obj0 = 0 ;
29869 PyObject * obj1 = 0 ;
29870 char * kwnames[] = {
29871 (char *) "self",(char *) "other", NULL
29872 };
29873
29874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29876 if (!SWIG_IsOK(res1)) {
29877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29878 }
29879 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29880 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29881 if (!SWIG_IsOK(res2)) {
29882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29883 }
29884 if (!argp2) {
29885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29886 }
29887 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29888 {
29889 PyThreadState* __tstate = wxPyBeginAllowThreads();
29890 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29891 wxPyEndAllowThreads(__tstate);
29892 if (PyErr_Occurred()) SWIG_fail;
29893 }
29894 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29895 return resultobj;
29896 fail:
29897 return NULL;
29898 }
29899
29900
29901 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29902 PyObject *resultobj = 0;
29903 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29904 wxDateSpan *arg2 = 0 ;
29905 wxDateSpan result;
29906 void *argp1 = 0 ;
29907 int res1 = 0 ;
29908 void *argp2 = 0 ;
29909 int res2 = 0 ;
29910 PyObject * obj0 = 0 ;
29911 PyObject * obj1 = 0 ;
29912 char * kwnames[] = {
29913 (char *) "self",(char *) "other", NULL
29914 };
29915
29916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29918 if (!SWIG_IsOK(res1)) {
29919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29920 }
29921 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29922 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29923 if (!SWIG_IsOK(res2)) {
29924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29925 }
29926 if (!argp2) {
29927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29928 }
29929 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29930 {
29931 PyThreadState* __tstate = wxPyBeginAllowThreads();
29932 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29933 wxPyEndAllowThreads(__tstate);
29934 if (PyErr_Occurred()) SWIG_fail;
29935 }
29936 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj = 0;
29945 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29946 int arg2 ;
29947 wxDateSpan result;
29948 void *argp1 = 0 ;
29949 int res1 = 0 ;
29950 int val2 ;
29951 int ecode2 = 0 ;
29952 PyObject * obj0 = 0 ;
29953 PyObject * obj1 = 0 ;
29954 char * kwnames[] = {
29955 (char *) "self",(char *) "n", NULL
29956 };
29957
29958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29960 if (!SWIG_IsOK(res1)) {
29961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29962 }
29963 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29964 ecode2 = SWIG_AsVal_int(obj1, &val2);
29965 if (!SWIG_IsOK(ecode2)) {
29966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29967 }
29968 arg2 = static_cast< int >(val2);
29969 {
29970 PyThreadState* __tstate = wxPyBeginAllowThreads();
29971 result = wxDateSpan___mul__(arg1,arg2);
29972 wxPyEndAllowThreads(__tstate);
29973 if (PyErr_Occurred()) SWIG_fail;
29974 }
29975 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29976 return resultobj;
29977 fail:
29978 return NULL;
29979 }
29980
29981
29982 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29983 PyObject *resultobj = 0;
29984 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29985 int arg2 ;
29986 wxDateSpan result;
29987 void *argp1 = 0 ;
29988 int res1 = 0 ;
29989 int val2 ;
29990 int ecode2 = 0 ;
29991 PyObject * obj0 = 0 ;
29992 PyObject * obj1 = 0 ;
29993 char * kwnames[] = {
29994 (char *) "self",(char *) "n", NULL
29995 };
29996
29997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29999 if (!SWIG_IsOK(res1)) {
30000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30001 }
30002 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30003 ecode2 = SWIG_AsVal_int(obj1, &val2);
30004 if (!SWIG_IsOK(ecode2)) {
30005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30006 }
30007 arg2 = static_cast< int >(val2);
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 result = wxDateSpan___rmul__(arg1,arg2);
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30022 PyObject *resultobj = 0;
30023 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30024 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30025 bool result;
30026 void *argp1 = 0 ;
30027 int res1 = 0 ;
30028 void *argp2 = 0 ;
30029 int res2 = 0 ;
30030 PyObject * obj0 = 0 ;
30031 PyObject * obj1 = 0 ;
30032 char * kwnames[] = {
30033 (char *) "self",(char *) "other", NULL
30034 };
30035
30036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30038 if (!SWIG_IsOK(res1)) {
30039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30040 }
30041 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30043 if (!SWIG_IsOK(res2)) {
30044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30045 }
30046 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30047 {
30048 PyThreadState* __tstate = wxPyBeginAllowThreads();
30049 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 {
30054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30055 }
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30063 PyObject *resultobj = 0;
30064 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30065 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30066 bool result;
30067 void *argp1 = 0 ;
30068 int res1 = 0 ;
30069 void *argp2 = 0 ;
30070 int res2 = 0 ;
30071 PyObject * obj0 = 0 ;
30072 PyObject * obj1 = 0 ;
30073 char * kwnames[] = {
30074 (char *) "self",(char *) "other", NULL
30075 };
30076
30077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30079 if (!SWIG_IsOK(res1)) {
30080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30081 }
30082 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30083 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30084 if (!SWIG_IsOK(res2)) {
30085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30086 }
30087 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30088 {
30089 PyThreadState* __tstate = wxPyBeginAllowThreads();
30090 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30091 wxPyEndAllowThreads(__tstate);
30092 if (PyErr_Occurred()) SWIG_fail;
30093 }
30094 {
30095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30096 }
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30104 PyObject *obj;
30105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30106 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30107 return SWIG_Py_Void();
30108 }
30109
30110 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30111 return SWIG_Python_InitShadowInstance(args);
30112 }
30113
30114 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30115 PyObject *resultobj = 0;
30116 long result;
30117
30118 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30119 {
30120 PyThreadState* __tstate = wxPyBeginAllowThreads();
30121 result = (long)wxGetLocalTime();
30122 wxPyEndAllowThreads(__tstate);
30123 if (PyErr_Occurred()) SWIG_fail;
30124 }
30125 resultobj = SWIG_From_long(static_cast< long >(result));
30126 return resultobj;
30127 fail:
30128 return NULL;
30129 }
30130
30131
30132 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30133 PyObject *resultobj = 0;
30134 long result;
30135
30136 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30137 {
30138 PyThreadState* __tstate = wxPyBeginAllowThreads();
30139 result = (long)wxGetUTCTime();
30140 wxPyEndAllowThreads(__tstate);
30141 if (PyErr_Occurred()) SWIG_fail;
30142 }
30143 resultobj = SWIG_From_long(static_cast< long >(result));
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30151 PyObject *resultobj = 0;
30152 long result;
30153
30154 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = (long)wxGetCurrentTime();
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 resultobj = SWIG_From_long(static_cast< long >(result));
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30169 PyObject *resultobj = 0;
30170 wxLongLong result;
30171
30172 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30173 {
30174 PyThreadState* __tstate = wxPyBeginAllowThreads();
30175 result = wxGetLocalTimeMillis();
30176 wxPyEndAllowThreads(__tstate);
30177 if (PyErr_Occurred()) SWIG_fail;
30178 }
30179 {
30180 PyObject *hi, *lo, *shifter, *shifted;
30181 hi = PyLong_FromLong( (&result)->GetHi() );
30182 lo = PyLong_FromLong( (&result)->GetLo() );
30183 shifter = PyLong_FromLong(32);
30184 shifted = PyNumber_Lshift(hi, shifter);
30185 resultobj = PyNumber_Or(shifted, lo);
30186 Py_DECREF(hi);
30187 Py_DECREF(lo);
30188 Py_DECREF(shifter);
30189 Py_DECREF(shifted);
30190 }
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30198 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30199 return 1;
30200 }
30201
30202
30203 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30204 PyObject *pyobj = 0;
30205
30206 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30207 return pyobj;
30208 }
30209
30210
30211 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30212 PyObject *resultobj = 0;
30213 wxDataFormatId arg1 ;
30214 wxDataFormat *result = 0 ;
30215 int val1 ;
30216 int ecode1 = 0 ;
30217 PyObject * obj0 = 0 ;
30218 char * kwnames[] = {
30219 (char *) "type", NULL
30220 };
30221
30222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30223 ecode1 = SWIG_AsVal_int(obj0, &val1);
30224 if (!SWIG_IsOK(ecode1)) {
30225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30226 }
30227 arg1 = static_cast< wxDataFormatId >(val1);
30228 {
30229 PyThreadState* __tstate = wxPyBeginAllowThreads();
30230 result = (wxDataFormat *)new wxDataFormat(arg1);
30231 wxPyEndAllowThreads(__tstate);
30232 if (PyErr_Occurred()) SWIG_fail;
30233 }
30234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30242 PyObject *resultobj = 0;
30243 wxString *arg1 = 0 ;
30244 wxDataFormat *result = 0 ;
30245 bool temp1 = false ;
30246 PyObject * obj0 = 0 ;
30247 char * kwnames[] = {
30248 (char *) "format", NULL
30249 };
30250
30251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30252 {
30253 arg1 = wxString_in_helper(obj0);
30254 if (arg1 == NULL) SWIG_fail;
30255 temp1 = true;
30256 }
30257 {
30258 PyThreadState* __tstate = wxPyBeginAllowThreads();
30259 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30260 wxPyEndAllowThreads(__tstate);
30261 if (PyErr_Occurred()) SWIG_fail;
30262 }
30263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30264 {
30265 if (temp1)
30266 delete arg1;
30267 }
30268 return resultobj;
30269 fail:
30270 {
30271 if (temp1)
30272 delete arg1;
30273 }
30274 return NULL;
30275 }
30276
30277
30278 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30279 PyObject *resultobj = 0;
30280 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30281 void *argp1 = 0 ;
30282 int res1 = 0 ;
30283 PyObject *swig_obj[1] ;
30284
30285 if (!args) SWIG_fail;
30286 swig_obj[0] = args;
30287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30288 if (!SWIG_IsOK(res1)) {
30289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30290 }
30291 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30292 {
30293 PyThreadState* __tstate = wxPyBeginAllowThreads();
30294 delete arg1;
30295
30296 wxPyEndAllowThreads(__tstate);
30297 if (PyErr_Occurred()) SWIG_fail;
30298 }
30299 resultobj = SWIG_Py_Void();
30300 return resultobj;
30301 fail:
30302 return NULL;
30303 }
30304
30305
30306 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30307 PyObject *resultobj = 0;
30308 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30309 wxDataFormatId arg2 ;
30310 bool result;
30311 void *argp1 = 0 ;
30312 int res1 = 0 ;
30313 int val2 ;
30314 int ecode2 = 0 ;
30315
30316 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30318 if (!SWIG_IsOK(res1)) {
30319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30320 }
30321 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30322 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30323 if (!SWIG_IsOK(ecode2)) {
30324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30325 }
30326 arg2 = static_cast< wxDataFormatId >(val2);
30327 {
30328 PyThreadState* __tstate = wxPyBeginAllowThreads();
30329 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30330 wxPyEndAllowThreads(__tstate);
30331 if (PyErr_Occurred()) SWIG_fail;
30332 }
30333 {
30334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30335 }
30336 return resultobj;
30337 fail:
30338 return NULL;
30339 }
30340
30341
30342 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30343 PyObject *resultobj = 0;
30344 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30345 wxDataFormatId arg2 ;
30346 bool result;
30347 void *argp1 = 0 ;
30348 int res1 = 0 ;
30349 int val2 ;
30350 int ecode2 = 0 ;
30351
30352 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30354 if (!SWIG_IsOK(res1)) {
30355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30356 }
30357 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30358 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30359 if (!SWIG_IsOK(ecode2)) {
30360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30361 }
30362 arg2 = static_cast< wxDataFormatId >(val2);
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 {
30370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30371 }
30372 return resultobj;
30373 fail:
30374 return NULL;
30375 }
30376
30377
30378 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30379 PyObject *resultobj = 0;
30380 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30381 wxDataFormat *arg2 = 0 ;
30382 bool result;
30383 void *argp1 = 0 ;
30384 int res1 = 0 ;
30385 void *argp2 = 0 ;
30386 int res2 = 0 ;
30387
30388 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30390 if (!SWIG_IsOK(res1)) {
30391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30392 }
30393 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30394 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30395 if (!SWIG_IsOK(res2)) {
30396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30397 }
30398 if (!argp2) {
30399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30400 }
30401 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30402 {
30403 PyThreadState* __tstate = wxPyBeginAllowThreads();
30404 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30405 wxPyEndAllowThreads(__tstate);
30406 if (PyErr_Occurred()) SWIG_fail;
30407 }
30408 {
30409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30410 }
30411 return resultobj;
30412 fail:
30413 return NULL;
30414 }
30415
30416
30417 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30418 int argc;
30419 PyObject *argv[3];
30420
30421 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30422 --argc;
30423 if (argc == 2) {
30424 int _v = 0;
30425 {
30426 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30427 _v = SWIG_CheckState(res);
30428 }
30429 if (!_v) goto check_1;
30430 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30431 }
30432 check_1:
30433
30434 if (argc == 2) {
30435 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30436 }
30437
30438 fail:
30439 Py_INCREF(Py_NotImplemented);
30440 return Py_NotImplemented;
30441 }
30442
30443
30444 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30445 PyObject *resultobj = 0;
30446 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30447 wxDataFormat *arg2 = 0 ;
30448 bool result;
30449 void *argp1 = 0 ;
30450 int res1 = 0 ;
30451 void *argp2 = 0 ;
30452 int res2 = 0 ;
30453
30454 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30456 if (!SWIG_IsOK(res1)) {
30457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30458 }
30459 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30460 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30461 if (!SWIG_IsOK(res2)) {
30462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30463 }
30464 if (!argp2) {
30465 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30466 }
30467 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30468 {
30469 PyThreadState* __tstate = wxPyBeginAllowThreads();
30470 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30471 wxPyEndAllowThreads(__tstate);
30472 if (PyErr_Occurred()) SWIG_fail;
30473 }
30474 {
30475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30476 }
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30484 int argc;
30485 PyObject *argv[3];
30486
30487 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30488 --argc;
30489 if (argc == 2) {
30490 int _v = 0;
30491 {
30492 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30493 _v = SWIG_CheckState(res);
30494 }
30495 if (!_v) goto check_1;
30496 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30497 }
30498 check_1:
30499
30500 if (argc == 2) {
30501 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30502 }
30503
30504 fail:
30505 Py_INCREF(Py_NotImplemented);
30506 return Py_NotImplemented;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30511 PyObject *resultobj = 0;
30512 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30513 wxDataFormatId arg2 ;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 int val2 ;
30517 int ecode2 = 0 ;
30518 PyObject * obj0 = 0 ;
30519 PyObject * obj1 = 0 ;
30520 char * kwnames[] = {
30521 (char *) "self",(char *) "format", NULL
30522 };
30523
30524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30526 if (!SWIG_IsOK(res1)) {
30527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30528 }
30529 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30530 ecode2 = SWIG_AsVal_int(obj1, &val2);
30531 if (!SWIG_IsOK(ecode2)) {
30532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30533 }
30534 arg2 = static_cast< wxDataFormatId >(val2);
30535 {
30536 PyThreadState* __tstate = wxPyBeginAllowThreads();
30537 (arg1)->SetType(arg2);
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 resultobj = SWIG_Py_Void();
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30549 PyObject *resultobj = 0;
30550 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30551 wxDataFormatId result;
30552 void *argp1 = 0 ;
30553 int res1 = 0 ;
30554 PyObject *swig_obj[1] ;
30555
30556 if (!args) SWIG_fail;
30557 swig_obj[0] = args;
30558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30559 if (!SWIG_IsOK(res1)) {
30560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30561 }
30562 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30563 {
30564 PyThreadState* __tstate = wxPyBeginAllowThreads();
30565 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30566 wxPyEndAllowThreads(__tstate);
30567 if (PyErr_Occurred()) SWIG_fail;
30568 }
30569 resultobj = SWIG_From_int(static_cast< int >(result));
30570 return resultobj;
30571 fail:
30572 return NULL;
30573 }
30574
30575
30576 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30577 PyObject *resultobj = 0;
30578 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30579 wxString result;
30580 void *argp1 = 0 ;
30581 int res1 = 0 ;
30582 PyObject *swig_obj[1] ;
30583
30584 if (!args) SWIG_fail;
30585 swig_obj[0] = args;
30586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30587 if (!SWIG_IsOK(res1)) {
30588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30589 }
30590 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30591 {
30592 PyThreadState* __tstate = wxPyBeginAllowThreads();
30593 result = ((wxDataFormat const *)arg1)->GetId();
30594 wxPyEndAllowThreads(__tstate);
30595 if (PyErr_Occurred()) SWIG_fail;
30596 }
30597 {
30598 #if wxUSE_UNICODE
30599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30600 #else
30601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30602 #endif
30603 }
30604 return resultobj;
30605 fail:
30606 return NULL;
30607 }
30608
30609
30610 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30611 PyObject *resultobj = 0;
30612 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30613 wxString *arg2 = 0 ;
30614 void *argp1 = 0 ;
30615 int res1 = 0 ;
30616 bool temp2 = false ;
30617 PyObject * obj0 = 0 ;
30618 PyObject * obj1 = 0 ;
30619 char * kwnames[] = {
30620 (char *) "self",(char *) "format", NULL
30621 };
30622
30623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30625 if (!SWIG_IsOK(res1)) {
30626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30627 }
30628 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30629 {
30630 arg2 = wxString_in_helper(obj1);
30631 if (arg2 == NULL) SWIG_fail;
30632 temp2 = true;
30633 }
30634 {
30635 PyThreadState* __tstate = wxPyBeginAllowThreads();
30636 (arg1)->SetId((wxString const &)*arg2);
30637 wxPyEndAllowThreads(__tstate);
30638 if (PyErr_Occurred()) SWIG_fail;
30639 }
30640 resultobj = SWIG_Py_Void();
30641 {
30642 if (temp2)
30643 delete arg2;
30644 }
30645 return resultobj;
30646 fail:
30647 {
30648 if (temp2)
30649 delete arg2;
30650 }
30651 return NULL;
30652 }
30653
30654
30655 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30656 PyObject *obj;
30657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30658 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30659 return SWIG_Py_Void();
30660 }
30661
30662 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30663 return SWIG_Python_InitShadowInstance(args);
30664 }
30665
30666 SWIGINTERN int FormatInvalid_set(PyObject *) {
30667 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30668 return 1;
30669 }
30670
30671
30672 SWIGINTERN PyObject *FormatInvalid_get(void) {
30673 PyObject *pyobj = 0;
30674
30675 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30676 return pyobj;
30677 }
30678
30679
30680 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30681 PyObject *resultobj = 0;
30682 wxDataObject *arg1 = (wxDataObject *) 0 ;
30683 void *argp1 = 0 ;
30684 int res1 = 0 ;
30685 PyObject *swig_obj[1] ;
30686
30687 if (!args) SWIG_fail;
30688 swig_obj[0] = args;
30689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30690 if (!SWIG_IsOK(res1)) {
30691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30692 }
30693 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30694 {
30695 PyThreadState* __tstate = wxPyBeginAllowThreads();
30696 delete arg1;
30697
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 resultobj = SWIG_Py_Void();
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj = 0;
30710 wxDataObject *arg1 = (wxDataObject *) 0 ;
30711 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30712 SwigValueWrapper<wxDataFormat > result;
30713 void *argp1 = 0 ;
30714 int res1 = 0 ;
30715 int val2 ;
30716 int ecode2 = 0 ;
30717 PyObject * obj0 = 0 ;
30718 PyObject * obj1 = 0 ;
30719 char * kwnames[] = {
30720 (char *) "self",(char *) "dir", NULL
30721 };
30722
30723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30725 if (!SWIG_IsOK(res1)) {
30726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30727 }
30728 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30729 if (obj1) {
30730 ecode2 = SWIG_AsVal_int(obj1, &val2);
30731 if (!SWIG_IsOK(ecode2)) {
30732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30733 }
30734 arg2 = static_cast< wxDataObject::Direction >(val2);
30735 }
30736 {
30737 PyThreadState* __tstate = wxPyBeginAllowThreads();
30738 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30739 wxPyEndAllowThreads(__tstate);
30740 if (PyErr_Occurred()) SWIG_fail;
30741 }
30742 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30743 return resultobj;
30744 fail:
30745 return NULL;
30746 }
30747
30748
30749 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30750 PyObject *resultobj = 0;
30751 wxDataObject *arg1 = (wxDataObject *) 0 ;
30752 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30753 size_t result;
30754 void *argp1 = 0 ;
30755 int res1 = 0 ;
30756 int val2 ;
30757 int ecode2 = 0 ;
30758 PyObject * obj0 = 0 ;
30759 PyObject * obj1 = 0 ;
30760 char * kwnames[] = {
30761 (char *) "self",(char *) "dir", NULL
30762 };
30763
30764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30766 if (!SWIG_IsOK(res1)) {
30767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30768 }
30769 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30770 if (obj1) {
30771 ecode2 = SWIG_AsVal_int(obj1, &val2);
30772 if (!SWIG_IsOK(ecode2)) {
30773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30774 }
30775 arg2 = static_cast< wxDataObject::Direction >(val2);
30776 }
30777 {
30778 PyThreadState* __tstate = wxPyBeginAllowThreads();
30779 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30780 wxPyEndAllowThreads(__tstate);
30781 if (PyErr_Occurred()) SWIG_fail;
30782 }
30783 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30784 return resultobj;
30785 fail:
30786 return NULL;
30787 }
30788
30789
30790 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30791 PyObject *resultobj = 0;
30792 wxDataObject *arg1 = (wxDataObject *) 0 ;
30793 wxDataFormat *arg2 = 0 ;
30794 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30795 bool result;
30796 void *argp1 = 0 ;
30797 int res1 = 0 ;
30798 void *argp2 = 0 ;
30799 int res2 = 0 ;
30800 int val3 ;
30801 int ecode3 = 0 ;
30802 PyObject * obj0 = 0 ;
30803 PyObject * obj1 = 0 ;
30804 PyObject * obj2 = 0 ;
30805 char * kwnames[] = {
30806 (char *) "self",(char *) "format",(char *) "dir", NULL
30807 };
30808
30809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30813 }
30814 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30815 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30816 if (!SWIG_IsOK(res2)) {
30817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30818 }
30819 if (!argp2) {
30820 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30821 }
30822 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30823 if (obj2) {
30824 ecode3 = SWIG_AsVal_int(obj2, &val3);
30825 if (!SWIG_IsOK(ecode3)) {
30826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30827 }
30828 arg3 = static_cast< wxDataObject::Direction >(val3);
30829 }
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 {
30837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30838 }
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30846 PyObject *resultobj = 0;
30847 wxDataObject *arg1 = (wxDataObject *) 0 ;
30848 wxDataFormat *arg2 = 0 ;
30849 size_t result;
30850 void *argp1 = 0 ;
30851 int res1 = 0 ;
30852 void *argp2 = 0 ;
30853 int res2 = 0 ;
30854 PyObject * obj0 = 0 ;
30855 PyObject * obj1 = 0 ;
30856 char * kwnames[] = {
30857 (char *) "self",(char *) "format", NULL
30858 };
30859
30860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30862 if (!SWIG_IsOK(res1)) {
30863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30864 }
30865 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30866 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30867 if (!SWIG_IsOK(res2)) {
30868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30869 }
30870 if (!argp2) {
30871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30872 }
30873 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30874 {
30875 PyThreadState* __tstate = wxPyBeginAllowThreads();
30876 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30877 wxPyEndAllowThreads(__tstate);
30878 if (PyErr_Occurred()) SWIG_fail;
30879 }
30880 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30881 return resultobj;
30882 fail:
30883 return NULL;
30884 }
30885
30886
30887 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30888 PyObject *resultobj = 0;
30889 wxDataObject *arg1 = (wxDataObject *) 0 ;
30890 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30891 PyObject *result = 0 ;
30892 void *argp1 = 0 ;
30893 int res1 = 0 ;
30894 int val2 ;
30895 int ecode2 = 0 ;
30896 PyObject * obj0 = 0 ;
30897 PyObject * obj1 = 0 ;
30898 char * kwnames[] = {
30899 (char *) "self",(char *) "dir", NULL
30900 };
30901
30902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30904 if (!SWIG_IsOK(res1)) {
30905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30906 }
30907 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30908 if (obj1) {
30909 ecode2 = SWIG_AsVal_int(obj1, &val2);
30910 if (!SWIG_IsOK(ecode2)) {
30911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30912 }
30913 arg2 = static_cast< wxDataObject::Direction >(val2);
30914 }
30915 {
30916 PyThreadState* __tstate = wxPyBeginAllowThreads();
30917 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30918 wxPyEndAllowThreads(__tstate);
30919 if (PyErr_Occurred()) SWIG_fail;
30920 }
30921 resultobj = result;
30922 return resultobj;
30923 fail:
30924 return NULL;
30925 }
30926
30927
30928 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30929 PyObject *resultobj = 0;
30930 wxDataObject *arg1 = (wxDataObject *) 0 ;
30931 wxDataFormat *arg2 = 0 ;
30932 PyObject *result = 0 ;
30933 void *argp1 = 0 ;
30934 int res1 = 0 ;
30935 void *argp2 = 0 ;
30936 int res2 = 0 ;
30937 PyObject * obj0 = 0 ;
30938 PyObject * obj1 = 0 ;
30939 char * kwnames[] = {
30940 (char *) "self",(char *) "format", NULL
30941 };
30942
30943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30945 if (!SWIG_IsOK(res1)) {
30946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30947 }
30948 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30950 if (!SWIG_IsOK(res2)) {
30951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30952 }
30953 if (!argp2) {
30954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30955 }
30956 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30960 wxPyEndAllowThreads(__tstate);
30961 if (PyErr_Occurred()) SWIG_fail;
30962 }
30963 resultobj = result;
30964 return resultobj;
30965 fail:
30966 return NULL;
30967 }
30968
30969
30970 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30971 PyObject *resultobj = 0;
30972 wxDataObject *arg1 = (wxDataObject *) 0 ;
30973 wxDataFormat *arg2 = 0 ;
30974 PyObject *arg3 = (PyObject *) 0 ;
30975 bool result;
30976 void *argp1 = 0 ;
30977 int res1 = 0 ;
30978 void *argp2 = 0 ;
30979 int res2 = 0 ;
30980 PyObject * obj0 = 0 ;
30981 PyObject * obj1 = 0 ;
30982 PyObject * obj2 = 0 ;
30983 char * kwnames[] = {
30984 (char *) "self",(char *) "format",(char *) "data", NULL
30985 };
30986
30987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) 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_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
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_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30996 }
30997 if (!argp2) {
30998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30999 }
31000 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31001 arg3 = obj2;
31002 {
31003 PyThreadState* __tstate = wxPyBeginAllowThreads();
31004 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31005 wxPyEndAllowThreads(__tstate);
31006 if (PyErr_Occurred()) SWIG_fail;
31007 }
31008 {
31009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31010 }
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31018 PyObject *obj;
31019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31020 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31021 return SWIG_Py_Void();
31022 }
31023
31024 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj = 0;
31026 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31027 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31028 wxDataObjectSimple *result = 0 ;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 PyObject * obj0 = 0 ;
31032 char * kwnames[] = {
31033 (char *) "format", NULL
31034 };
31035
31036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31037 if (obj0) {
31038 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31039 if (!SWIG_IsOK(res1)) {
31040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31041 }
31042 if (!argp1) {
31043 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31044 }
31045 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31046 }
31047 {
31048 PyThreadState* __tstate = wxPyBeginAllowThreads();
31049 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31061 PyObject *resultobj = 0;
31062 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31063 wxDataFormat *result = 0 ;
31064 void *argp1 = 0 ;
31065 int res1 = 0 ;
31066 PyObject *swig_obj[1] ;
31067
31068 if (!args) SWIG_fail;
31069 swig_obj[0] = args;
31070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31071 if (!SWIG_IsOK(res1)) {
31072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31073 }
31074 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 {
31078 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31079 result = (wxDataFormat *) &_result_ref;
31080 }
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31085 return resultobj;
31086 fail:
31087 return NULL;
31088 }
31089
31090
31091 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31092 PyObject *resultobj = 0;
31093 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31094 wxDataFormat *arg2 = 0 ;
31095 void *argp1 = 0 ;
31096 int res1 = 0 ;
31097 void *argp2 = 0 ;
31098 int res2 = 0 ;
31099 PyObject * obj0 = 0 ;
31100 PyObject * obj1 = 0 ;
31101 char * kwnames[] = {
31102 (char *) "self",(char *) "format", NULL
31103 };
31104
31105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31107 if (!SWIG_IsOK(res1)) {
31108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31109 }
31110 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31111 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31112 if (!SWIG_IsOK(res2)) {
31113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31114 }
31115 if (!argp2) {
31116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31117 }
31118 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31122 wxPyEndAllowThreads(__tstate);
31123 if (PyErr_Occurred()) SWIG_fail;
31124 }
31125 resultobj = SWIG_Py_Void();
31126 return resultobj;
31127 fail:
31128 return NULL;
31129 }
31130
31131
31132 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31133 PyObject *resultobj = 0;
31134 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31135 size_t result;
31136 void *argp1 = 0 ;
31137 int res1 = 0 ;
31138 PyObject *swig_obj[1] ;
31139
31140 if (!args) SWIG_fail;
31141 swig_obj[0] = args;
31142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31143 if (!SWIG_IsOK(res1)) {
31144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31145 }
31146 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31161 PyObject *resultobj = 0;
31162 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31163 PyObject *result = 0 ;
31164 void *argp1 = 0 ;
31165 int res1 = 0 ;
31166 PyObject *swig_obj[1] ;
31167
31168 if (!args) SWIG_fail;
31169 swig_obj[0] = args;
31170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31171 if (!SWIG_IsOK(res1)) {
31172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31173 }
31174 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31175 {
31176 PyThreadState* __tstate = wxPyBeginAllowThreads();
31177 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 resultobj = result;
31182 return resultobj;
31183 fail:
31184 return NULL;
31185 }
31186
31187
31188 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31189 PyObject *resultobj = 0;
31190 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31191 PyObject *arg2 = (PyObject *) 0 ;
31192 bool result;
31193 void *argp1 = 0 ;
31194 int res1 = 0 ;
31195 PyObject * obj0 = 0 ;
31196 PyObject * obj1 = 0 ;
31197 char * kwnames[] = {
31198 (char *) "self",(char *) "data", NULL
31199 };
31200
31201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31203 if (!SWIG_IsOK(res1)) {
31204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31205 }
31206 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31207 arg2 = obj1;
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 {
31215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31216 }
31217 return resultobj;
31218 fail:
31219 return NULL;
31220 }
31221
31222
31223 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31224 PyObject *obj;
31225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31226 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31227 return SWIG_Py_Void();
31228 }
31229
31230 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31231 return SWIG_Python_InitShadowInstance(args);
31232 }
31233
31234 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31235 PyObject *resultobj = 0;
31236 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31237 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31238 wxPyDataObjectSimple *result = 0 ;
31239 void *argp1 = 0 ;
31240 int res1 = 0 ;
31241 PyObject * obj0 = 0 ;
31242 char * kwnames[] = {
31243 (char *) "format", NULL
31244 };
31245
31246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31247 if (obj0) {
31248 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31249 if (!SWIG_IsOK(res1)) {
31250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31251 }
31252 if (!argp1) {
31253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31254 }
31255 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31256 }
31257 {
31258 PyThreadState* __tstate = wxPyBeginAllowThreads();
31259 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31260 wxPyEndAllowThreads(__tstate);
31261 if (PyErr_Occurred()) SWIG_fail;
31262 }
31263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31264 return resultobj;
31265 fail:
31266 return NULL;
31267 }
31268
31269
31270 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31271 PyObject *resultobj = 0;
31272 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31273 PyObject *arg2 = (PyObject *) 0 ;
31274 PyObject *arg3 = (PyObject *) 0 ;
31275 void *argp1 = 0 ;
31276 int res1 = 0 ;
31277 PyObject * obj0 = 0 ;
31278 PyObject * obj1 = 0 ;
31279 PyObject * obj2 = 0 ;
31280 char * kwnames[] = {
31281 (char *) "self",(char *) "self",(char *) "_class", NULL
31282 };
31283
31284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31286 if (!SWIG_IsOK(res1)) {
31287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31288 }
31289 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31290 arg2 = obj1;
31291 arg3 = obj2;
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 (arg1)->_setCallbackInfo(arg2,arg3);
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_Py_Void();
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31306 PyObject *obj;
31307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31308 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31309 return SWIG_Py_Void();
31310 }
31311
31312 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31313 return SWIG_Python_InitShadowInstance(args);
31314 }
31315
31316 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31317 PyObject *resultobj = 0;
31318 wxDataObjectComposite *result = 0 ;
31319
31320 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31321 {
31322 PyThreadState* __tstate = wxPyBeginAllowThreads();
31323 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31324 wxPyEndAllowThreads(__tstate);
31325 if (PyErr_Occurred()) SWIG_fail;
31326 }
31327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31328 return resultobj;
31329 fail:
31330 return NULL;
31331 }
31332
31333
31334 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31335 PyObject *resultobj = 0;
31336 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31337 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31338 bool arg3 = (bool) false ;
31339 void *argp1 = 0 ;
31340 int res1 = 0 ;
31341 int res2 = 0 ;
31342 bool val3 ;
31343 int ecode3 = 0 ;
31344 PyObject * obj0 = 0 ;
31345 PyObject * obj1 = 0 ;
31346 PyObject * obj2 = 0 ;
31347 char * kwnames[] = {
31348 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31349 };
31350
31351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31353 if (!SWIG_IsOK(res1)) {
31354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31355 }
31356 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31357 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31358 if (!SWIG_IsOK(res2)) {
31359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31360 }
31361 if (obj2) {
31362 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31363 if (!SWIG_IsOK(ecode3)) {
31364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31365 }
31366 arg3 = static_cast< bool >(val3);
31367 }
31368 {
31369 PyThreadState* __tstate = wxPyBeginAllowThreads();
31370 (arg1)->Add(arg2,arg3);
31371 wxPyEndAllowThreads(__tstate);
31372 if (PyErr_Occurred()) SWIG_fail;
31373 }
31374 resultobj = SWIG_Py_Void();
31375 return resultobj;
31376 fail:
31377 return NULL;
31378 }
31379
31380
31381 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31382 PyObject *resultobj = 0;
31383 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31384 SwigValueWrapper<wxDataFormat > result;
31385 void *argp1 = 0 ;
31386 int res1 = 0 ;
31387 PyObject *swig_obj[1] ;
31388
31389 if (!args) SWIG_fail;
31390 swig_obj[0] = args;
31391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31392 if (!SWIG_IsOK(res1)) {
31393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31394 }
31395 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31396 {
31397 PyThreadState* __tstate = wxPyBeginAllowThreads();
31398 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31399 wxPyEndAllowThreads(__tstate);
31400 if (PyErr_Occurred()) SWIG_fail;
31401 }
31402 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31403 return resultobj;
31404 fail:
31405 return NULL;
31406 }
31407
31408
31409 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31410 PyObject *obj;
31411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31412 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31413 return SWIG_Py_Void();
31414 }
31415
31416 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31417 return SWIG_Python_InitShadowInstance(args);
31418 }
31419
31420 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31421 PyObject *resultobj = 0;
31422 wxString const &arg1_defvalue = wxPyEmptyString ;
31423 wxString *arg1 = (wxString *) &arg1_defvalue ;
31424 wxTextDataObject *result = 0 ;
31425 bool temp1 = false ;
31426 PyObject * obj0 = 0 ;
31427 char * kwnames[] = {
31428 (char *) "text", NULL
31429 };
31430
31431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31432 if (obj0) {
31433 {
31434 arg1 = wxString_in_helper(obj0);
31435 if (arg1 == NULL) SWIG_fail;
31436 temp1 = true;
31437 }
31438 }
31439 {
31440 PyThreadState* __tstate = wxPyBeginAllowThreads();
31441 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31442 wxPyEndAllowThreads(__tstate);
31443 if (PyErr_Occurred()) SWIG_fail;
31444 }
31445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31446 {
31447 if (temp1)
31448 delete arg1;
31449 }
31450 return resultobj;
31451 fail:
31452 {
31453 if (temp1)
31454 delete arg1;
31455 }
31456 return NULL;
31457 }
31458
31459
31460 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31461 PyObject *resultobj = 0;
31462 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31463 size_t result;
31464 void *argp1 = 0 ;
31465 int res1 = 0 ;
31466 PyObject *swig_obj[1] ;
31467
31468 if (!args) SWIG_fail;
31469 swig_obj[0] = args;
31470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31471 if (!SWIG_IsOK(res1)) {
31472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31473 }
31474 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 result = (size_t)(arg1)->GetTextLength();
31478 wxPyEndAllowThreads(__tstate);
31479 if (PyErr_Occurred()) SWIG_fail;
31480 }
31481 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31482 return resultobj;
31483 fail:
31484 return NULL;
31485 }
31486
31487
31488 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31489 PyObject *resultobj = 0;
31490 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31491 wxString result;
31492 void *argp1 = 0 ;
31493 int res1 = 0 ;
31494 PyObject *swig_obj[1] ;
31495
31496 if (!args) SWIG_fail;
31497 swig_obj[0] = args;
31498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31499 if (!SWIG_IsOK(res1)) {
31500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31501 }
31502 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31503 {
31504 PyThreadState* __tstate = wxPyBeginAllowThreads();
31505 result = (arg1)->GetText();
31506 wxPyEndAllowThreads(__tstate);
31507 if (PyErr_Occurred()) SWIG_fail;
31508 }
31509 {
31510 #if wxUSE_UNICODE
31511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31512 #else
31513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31514 #endif
31515 }
31516 return resultobj;
31517 fail:
31518 return NULL;
31519 }
31520
31521
31522 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31523 PyObject *resultobj = 0;
31524 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31525 wxString *arg2 = 0 ;
31526 void *argp1 = 0 ;
31527 int res1 = 0 ;
31528 bool temp2 = false ;
31529 PyObject * obj0 = 0 ;
31530 PyObject * obj1 = 0 ;
31531 char * kwnames[] = {
31532 (char *) "self",(char *) "text", NULL
31533 };
31534
31535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31537 if (!SWIG_IsOK(res1)) {
31538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31539 }
31540 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31541 {
31542 arg2 = wxString_in_helper(obj1);
31543 if (arg2 == NULL) SWIG_fail;
31544 temp2 = true;
31545 }
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 (arg1)->SetText((wxString const &)*arg2);
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_Py_Void();
31553 {
31554 if (temp2)
31555 delete arg2;
31556 }
31557 return resultobj;
31558 fail:
31559 {
31560 if (temp2)
31561 delete arg2;
31562 }
31563 return NULL;
31564 }
31565
31566
31567 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31568 PyObject *obj;
31569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31570 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31571 return SWIG_Py_Void();
31572 }
31573
31574 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31575 return SWIG_Python_InitShadowInstance(args);
31576 }
31577
31578 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31579 PyObject *resultobj = 0;
31580 wxString const &arg1_defvalue = wxPyEmptyString ;
31581 wxString *arg1 = (wxString *) &arg1_defvalue ;
31582 wxPyTextDataObject *result = 0 ;
31583 bool temp1 = false ;
31584 PyObject * obj0 = 0 ;
31585 char * kwnames[] = {
31586 (char *) "text", NULL
31587 };
31588
31589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31590 if (obj0) {
31591 {
31592 arg1 = wxString_in_helper(obj0);
31593 if (arg1 == NULL) SWIG_fail;
31594 temp1 = true;
31595 }
31596 }
31597 {
31598 PyThreadState* __tstate = wxPyBeginAllowThreads();
31599 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31600 wxPyEndAllowThreads(__tstate);
31601 if (PyErr_Occurred()) SWIG_fail;
31602 }
31603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31604 {
31605 if (temp1)
31606 delete arg1;
31607 }
31608 return resultobj;
31609 fail:
31610 {
31611 if (temp1)
31612 delete arg1;
31613 }
31614 return NULL;
31615 }
31616
31617
31618 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31619 PyObject *resultobj = 0;
31620 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31621 PyObject *arg2 = (PyObject *) 0 ;
31622 PyObject *arg3 = (PyObject *) 0 ;
31623 void *argp1 = 0 ;
31624 int res1 = 0 ;
31625 PyObject * obj0 = 0 ;
31626 PyObject * obj1 = 0 ;
31627 PyObject * obj2 = 0 ;
31628 char * kwnames[] = {
31629 (char *) "self",(char *) "self",(char *) "_class", NULL
31630 };
31631
31632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31634 if (!SWIG_IsOK(res1)) {
31635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31636 }
31637 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31638 arg2 = obj1;
31639 arg3 = obj2;
31640 {
31641 PyThreadState* __tstate = wxPyBeginAllowThreads();
31642 (arg1)->_setCallbackInfo(arg2,arg3);
31643 wxPyEndAllowThreads(__tstate);
31644 if (PyErr_Occurred()) SWIG_fail;
31645 }
31646 resultobj = SWIG_Py_Void();
31647 return resultobj;
31648 fail:
31649 return NULL;
31650 }
31651
31652
31653 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31654 PyObject *obj;
31655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31656 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31657 return SWIG_Py_Void();
31658 }
31659
31660 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31661 return SWIG_Python_InitShadowInstance(args);
31662 }
31663
31664 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31665 PyObject *resultobj = 0;
31666 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31667 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31668 wxBitmapDataObject *result = 0 ;
31669 void *argp1 = 0 ;
31670 int res1 = 0 ;
31671 PyObject * obj0 = 0 ;
31672 char * kwnames[] = {
31673 (char *) "bitmap", NULL
31674 };
31675
31676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31677 if (obj0) {
31678 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31679 if (!SWIG_IsOK(res1)) {
31680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31681 }
31682 if (!argp1) {
31683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31684 }
31685 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31686 }
31687 {
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31690 wxPyEndAllowThreads(__tstate);
31691 if (PyErr_Occurred()) SWIG_fail;
31692 }
31693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31694 return resultobj;
31695 fail:
31696 return NULL;
31697 }
31698
31699
31700 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31701 PyObject *resultobj = 0;
31702 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31703 wxBitmap result;
31704 void *argp1 = 0 ;
31705 int res1 = 0 ;
31706 PyObject *swig_obj[1] ;
31707
31708 if (!args) SWIG_fail;
31709 swig_obj[0] = args;
31710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31711 if (!SWIG_IsOK(res1)) {
31712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31713 }
31714 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31715 {
31716 PyThreadState* __tstate = wxPyBeginAllowThreads();
31717 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31718 wxPyEndAllowThreads(__tstate);
31719 if (PyErr_Occurred()) SWIG_fail;
31720 }
31721 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31722 return resultobj;
31723 fail:
31724 return NULL;
31725 }
31726
31727
31728 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31729 PyObject *resultobj = 0;
31730 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31731 wxBitmap *arg2 = 0 ;
31732 void *argp1 = 0 ;
31733 int res1 = 0 ;
31734 void *argp2 = 0 ;
31735 int res2 = 0 ;
31736 PyObject * obj0 = 0 ;
31737 PyObject * obj1 = 0 ;
31738 char * kwnames[] = {
31739 (char *) "self",(char *) "bitmap", NULL
31740 };
31741
31742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31744 if (!SWIG_IsOK(res1)) {
31745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31746 }
31747 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31748 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31749 if (!SWIG_IsOK(res2)) {
31750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31751 }
31752 if (!argp2) {
31753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31754 }
31755 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31756 {
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31759 wxPyEndAllowThreads(__tstate);
31760 if (PyErr_Occurred()) SWIG_fail;
31761 }
31762 resultobj = SWIG_Py_Void();
31763 return resultobj;
31764 fail:
31765 return NULL;
31766 }
31767
31768
31769 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31770 PyObject *obj;
31771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31772 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31773 return SWIG_Py_Void();
31774 }
31775
31776 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31777 return SWIG_Python_InitShadowInstance(args);
31778 }
31779
31780 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31781 PyObject *resultobj = 0;
31782 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31783 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31784 wxPyBitmapDataObject *result = 0 ;
31785 void *argp1 = 0 ;
31786 int res1 = 0 ;
31787 PyObject * obj0 = 0 ;
31788 char * kwnames[] = {
31789 (char *) "bitmap", NULL
31790 };
31791
31792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31793 if (obj0) {
31794 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31795 if (!SWIG_IsOK(res1)) {
31796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31797 }
31798 if (!argp1) {
31799 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31800 }
31801 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31802 }
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31817 PyObject *resultobj = 0;
31818 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31819 PyObject *arg2 = (PyObject *) 0 ;
31820 PyObject *arg3 = (PyObject *) 0 ;
31821 void *argp1 = 0 ;
31822 int res1 = 0 ;
31823 PyObject * obj0 = 0 ;
31824 PyObject * obj1 = 0 ;
31825 PyObject * obj2 = 0 ;
31826 char * kwnames[] = {
31827 (char *) "self",(char *) "self",(char *) "_class", NULL
31828 };
31829
31830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31832 if (!SWIG_IsOK(res1)) {
31833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31834 }
31835 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31836 arg2 = obj1;
31837 arg3 = obj2;
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 (arg1)->_setCallbackInfo(arg2,arg3);
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 resultobj = SWIG_Py_Void();
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31852 PyObject *obj;
31853 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31854 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31855 return SWIG_Py_Void();
31856 }
31857
31858 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31859 return SWIG_Python_InitShadowInstance(args);
31860 }
31861
31862 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31863 PyObject *resultobj = 0;
31864 wxFileDataObject *result = 0 ;
31865
31866 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = (wxFileDataObject *)new wxFileDataObject();
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881 PyObject *resultobj = 0;
31882 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31883 wxArrayString *result = 0 ;
31884 void *argp1 = 0 ;
31885 int res1 = 0 ;
31886 PyObject *swig_obj[1] ;
31887
31888 if (!args) SWIG_fail;
31889 swig_obj[0] = args;
31890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31891 if (!SWIG_IsOK(res1)) {
31892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31893 }
31894 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31895 {
31896 PyThreadState* __tstate = wxPyBeginAllowThreads();
31897 {
31898 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31899 result = (wxArrayString *) &_result_ref;
31900 }
31901 wxPyEndAllowThreads(__tstate);
31902 if (PyErr_Occurred()) SWIG_fail;
31903 }
31904 {
31905 resultobj = wxArrayString2PyList_helper(*result);
31906 }
31907 return resultobj;
31908 fail:
31909 return NULL;
31910 }
31911
31912
31913 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31914 PyObject *resultobj = 0;
31915 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31916 wxString *arg2 = 0 ;
31917 void *argp1 = 0 ;
31918 int res1 = 0 ;
31919 bool temp2 = false ;
31920 PyObject * obj0 = 0 ;
31921 PyObject * obj1 = 0 ;
31922 char * kwnames[] = {
31923 (char *) "self",(char *) "filename", NULL
31924 };
31925
31926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31928 if (!SWIG_IsOK(res1)) {
31929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31930 }
31931 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31932 {
31933 arg2 = wxString_in_helper(obj1);
31934 if (arg2 == NULL) SWIG_fail;
31935 temp2 = true;
31936 }
31937 {
31938 PyThreadState* __tstate = wxPyBeginAllowThreads();
31939 (arg1)->AddFile((wxString const &)*arg2);
31940 wxPyEndAllowThreads(__tstate);
31941 if (PyErr_Occurred()) SWIG_fail;
31942 }
31943 resultobj = SWIG_Py_Void();
31944 {
31945 if (temp2)
31946 delete arg2;
31947 }
31948 return resultobj;
31949 fail:
31950 {
31951 if (temp2)
31952 delete arg2;
31953 }
31954 return NULL;
31955 }
31956
31957
31958 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31959 PyObject *obj;
31960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31961 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31962 return SWIG_Py_Void();
31963 }
31964
31965 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31966 return SWIG_Python_InitShadowInstance(args);
31967 }
31968
31969 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31970 PyObject *resultobj = 0;
31971 wxDataFormat *arg1 = 0 ;
31972 wxCustomDataObject *result = 0 ;
31973 void *argp1 = 0 ;
31974 int res1 = 0 ;
31975
31976 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31978 if (!SWIG_IsOK(res1)) {
31979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31980 }
31981 if (!argp1) {
31982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31983 }
31984 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31985 {
31986 PyThreadState* __tstate = wxPyBeginAllowThreads();
31987 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31988 wxPyEndAllowThreads(__tstate);
31989 if (PyErr_Occurred()) SWIG_fail;
31990 }
31991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31992 return resultobj;
31993 fail:
31994 return NULL;
31995 }
31996
31997
31998 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31999 PyObject *resultobj = 0;
32000 wxString *arg1 = 0 ;
32001 wxCustomDataObject *result = 0 ;
32002 bool temp1 = false ;
32003
32004 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32005 {
32006 arg1 = wxString_in_helper(swig_obj[0]);
32007 if (arg1 == NULL) SWIG_fail;
32008 temp1 = true;
32009 }
32010 {
32011 PyThreadState* __tstate = wxPyBeginAllowThreads();
32012 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32013 wxPyEndAllowThreads(__tstate);
32014 if (PyErr_Occurred()) SWIG_fail;
32015 }
32016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32017 {
32018 if (temp1)
32019 delete arg1;
32020 }
32021 return resultobj;
32022 fail:
32023 {
32024 if (temp1)
32025 delete arg1;
32026 }
32027 return NULL;
32028 }
32029
32030
32031 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32032 PyObject *resultobj = 0;
32033 wxCustomDataObject *result = 0 ;
32034
32035 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = (wxCustomDataObject *)new wxCustomDataObject();
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32050 int argc;
32051 PyObject *argv[2];
32052
32053 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32054 --argc;
32055 if (argc == 0) {
32056 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32057 }
32058 if (argc == 1) {
32059 int _v = 0;
32060 {
32061 {
32062 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32063 }
32064 }
32065 if (!_v) goto check_2;
32066 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32067 }
32068 check_2:
32069
32070 if (argc == 1) {
32071 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32072 }
32073
32074 fail:
32075 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32076 return NULL;
32077 }
32078
32079
32080 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32081 PyObject *resultobj = 0;
32082 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32083 PyObject *arg2 = (PyObject *) 0 ;
32084 bool result;
32085 void *argp1 = 0 ;
32086 int res1 = 0 ;
32087 PyObject * obj0 = 0 ;
32088 PyObject * obj1 = 0 ;
32089 char * kwnames[] = {
32090 (char *) "self",(char *) "data", NULL
32091 };
32092
32093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32095 if (!SWIG_IsOK(res1)) {
32096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32097 }
32098 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32099 arg2 = obj1;
32100 {
32101 PyThreadState* __tstate = wxPyBeginAllowThreads();
32102 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32103 wxPyEndAllowThreads(__tstate);
32104 if (PyErr_Occurred()) SWIG_fail;
32105 }
32106 {
32107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32108 }
32109 return resultobj;
32110 fail:
32111 return NULL;
32112 }
32113
32114
32115 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32116 PyObject *resultobj = 0;
32117 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32118 size_t result;
32119 void *argp1 = 0 ;
32120 int res1 = 0 ;
32121 PyObject *swig_obj[1] ;
32122
32123 if (!args) SWIG_fail;
32124 swig_obj[0] = args;
32125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32126 if (!SWIG_IsOK(res1)) {
32127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32128 }
32129 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32130 {
32131 PyThreadState* __tstate = wxPyBeginAllowThreads();
32132 result = (size_t)(arg1)->GetSize();
32133 wxPyEndAllowThreads(__tstate);
32134 if (PyErr_Occurred()) SWIG_fail;
32135 }
32136 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32137 return resultobj;
32138 fail:
32139 return NULL;
32140 }
32141
32142
32143 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32144 PyObject *resultobj = 0;
32145 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32146 PyObject *result = 0 ;
32147 void *argp1 = 0 ;
32148 int res1 = 0 ;
32149 PyObject *swig_obj[1] ;
32150
32151 if (!args) SWIG_fail;
32152 swig_obj[0] = args;
32153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32154 if (!SWIG_IsOK(res1)) {
32155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32156 }
32157 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32158 {
32159 PyThreadState* __tstate = wxPyBeginAllowThreads();
32160 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32161 wxPyEndAllowThreads(__tstate);
32162 if (PyErr_Occurred()) SWIG_fail;
32163 }
32164 resultobj = result;
32165 return resultobj;
32166 fail:
32167 return NULL;
32168 }
32169
32170
32171 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32172 PyObject *obj;
32173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32174 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32175 return SWIG_Py_Void();
32176 }
32177
32178 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32179 return SWIG_Python_InitShadowInstance(args);
32180 }
32181
32182 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32183 PyObject *resultobj = 0;
32184 wxURLDataObject *result = 0 ;
32185
32186 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32187 {
32188 PyThreadState* __tstate = wxPyBeginAllowThreads();
32189 result = (wxURLDataObject *)new wxURLDataObject();
32190 wxPyEndAllowThreads(__tstate);
32191 if (PyErr_Occurred()) SWIG_fail;
32192 }
32193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32194 return resultobj;
32195 fail:
32196 return NULL;
32197 }
32198
32199
32200 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32201 PyObject *resultobj = 0;
32202 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32203 wxString result;
32204 void *argp1 = 0 ;
32205 int res1 = 0 ;
32206 PyObject *swig_obj[1] ;
32207
32208 if (!args) SWIG_fail;
32209 swig_obj[0] = args;
32210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32211 if (!SWIG_IsOK(res1)) {
32212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32213 }
32214 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (arg1)->GetURL();
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 {
32222 #if wxUSE_UNICODE
32223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32224 #else
32225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32226 #endif
32227 }
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32237 wxString *arg2 = 0 ;
32238 void *argp1 = 0 ;
32239 int res1 = 0 ;
32240 bool temp2 = false ;
32241 PyObject * obj0 = 0 ;
32242 PyObject * obj1 = 0 ;
32243 char * kwnames[] = {
32244 (char *) "self",(char *) "url", NULL
32245 };
32246
32247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32249 if (!SWIG_IsOK(res1)) {
32250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32251 }
32252 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32253 {
32254 arg2 = wxString_in_helper(obj1);
32255 if (arg2 == NULL) SWIG_fail;
32256 temp2 = true;
32257 }
32258 {
32259 PyThreadState* __tstate = wxPyBeginAllowThreads();
32260 (arg1)->SetURL((wxString const &)*arg2);
32261 wxPyEndAllowThreads(__tstate);
32262 if (PyErr_Occurred()) SWIG_fail;
32263 }
32264 resultobj = SWIG_Py_Void();
32265 {
32266 if (temp2)
32267 delete arg2;
32268 }
32269 return resultobj;
32270 fail:
32271 {
32272 if (temp2)
32273 delete arg2;
32274 }
32275 return NULL;
32276 }
32277
32278
32279 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32280 PyObject *obj;
32281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32282 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32283 return SWIG_Py_Void();
32284 }
32285
32286 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32287 return SWIG_Python_InitShadowInstance(args);
32288 }
32289
32290 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32291 PyObject *resultobj = 0;
32292 wxMetafileDataObject *result = 0 ;
32293
32294 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32295 {
32296 PyThreadState* __tstate = wxPyBeginAllowThreads();
32297 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32298 wxPyEndAllowThreads(__tstate);
32299 if (PyErr_Occurred()) SWIG_fail;
32300 }
32301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32302 return resultobj;
32303 fail:
32304 return NULL;
32305 }
32306
32307
32308 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32309 PyObject *resultobj = 0;
32310 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32311 wxMetafile *arg2 = 0 ;
32312 void *argp1 = 0 ;
32313 int res1 = 0 ;
32314 void *argp2 = 0 ;
32315 int res2 = 0 ;
32316 PyObject * obj0 = 0 ;
32317 PyObject * obj1 = 0 ;
32318 char * kwnames[] = {
32319 (char *) "self",(char *) "metafile", NULL
32320 };
32321
32322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32324 if (!SWIG_IsOK(res1)) {
32325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32326 }
32327 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32329 if (!SWIG_IsOK(res2)) {
32330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32331 }
32332 if (!argp2) {
32333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32334 }
32335 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32339 wxPyEndAllowThreads(__tstate);
32340 if (PyErr_Occurred()) SWIG_fail;
32341 }
32342 resultobj = SWIG_Py_Void();
32343 return resultobj;
32344 fail:
32345 return NULL;
32346 }
32347
32348
32349 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32350 PyObject *resultobj = 0;
32351 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32352 wxMetafile result;
32353 void *argp1 = 0 ;
32354 int res1 = 0 ;
32355 PyObject *swig_obj[1] ;
32356
32357 if (!args) SWIG_fail;
32358 swig_obj[0] = args;
32359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32360 if (!SWIG_IsOK(res1)) {
32361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32362 }
32363 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32378 PyObject *obj;
32379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32380 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32381 return SWIG_Py_Void();
32382 }
32383
32384 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32385 return SWIG_Python_InitShadowInstance(args);
32386 }
32387
32388 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32389 PyObject *resultobj = 0;
32390 wxDragResult arg1 ;
32391 bool result;
32392 int val1 ;
32393 int ecode1 = 0 ;
32394 PyObject * obj0 = 0 ;
32395 char * kwnames[] = {
32396 (char *) "res", NULL
32397 };
32398
32399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32400 ecode1 = SWIG_AsVal_int(obj0, &val1);
32401 if (!SWIG_IsOK(ecode1)) {
32402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32403 }
32404 arg1 = static_cast< wxDragResult >(val1);
32405 {
32406 PyThreadState* __tstate = wxPyBeginAllowThreads();
32407 result = (bool)wxIsDragResultOk(arg1);
32408 wxPyEndAllowThreads(__tstate);
32409 if (PyErr_Occurred()) SWIG_fail;
32410 }
32411 {
32412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32413 }
32414 return resultobj;
32415 fail:
32416 return NULL;
32417 }
32418
32419
32420 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32421 PyObject *resultobj = 0;
32422 wxWindow *arg1 = (wxWindow *) 0 ;
32423 wxCursor const &arg2_defvalue = wxNullCursor ;
32424 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32425 wxCursor const &arg3_defvalue = wxNullCursor ;
32426 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32427 wxCursor const &arg4_defvalue = wxNullCursor ;
32428 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32429 wxPyDropSource *result = 0 ;
32430 void *argp1 = 0 ;
32431 int res1 = 0 ;
32432 void *argp2 = 0 ;
32433 int res2 = 0 ;
32434 void *argp3 = 0 ;
32435 int res3 = 0 ;
32436 void *argp4 = 0 ;
32437 int res4 = 0 ;
32438 PyObject * obj0 = 0 ;
32439 PyObject * obj1 = 0 ;
32440 PyObject * obj2 = 0 ;
32441 PyObject * obj3 = 0 ;
32442 char * kwnames[] = {
32443 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32444 };
32445
32446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32448 if (!SWIG_IsOK(res1)) {
32449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32450 }
32451 arg1 = reinterpret_cast< wxWindow * >(argp1);
32452 if (obj1) {
32453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32454 if (!SWIG_IsOK(res2)) {
32455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32456 }
32457 if (!argp2) {
32458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32459 }
32460 arg2 = reinterpret_cast< wxCursor * >(argp2);
32461 }
32462 if (obj2) {
32463 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32464 if (!SWIG_IsOK(res3)) {
32465 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32466 }
32467 if (!argp3) {
32468 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32469 }
32470 arg3 = reinterpret_cast< wxCursor * >(argp3);
32471 }
32472 if (obj3) {
32473 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32474 if (!SWIG_IsOK(res4)) {
32475 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32476 }
32477 if (!argp4) {
32478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32479 }
32480 arg4 = reinterpret_cast< wxCursor * >(argp4);
32481 }
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32489 return resultobj;
32490 fail:
32491 return NULL;
32492 }
32493
32494
32495 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32496 PyObject *resultobj = 0;
32497 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32498 PyObject *arg2 = (PyObject *) 0 ;
32499 PyObject *arg3 = (PyObject *) 0 ;
32500 int arg4 ;
32501 void *argp1 = 0 ;
32502 int res1 = 0 ;
32503 int val4 ;
32504 int ecode4 = 0 ;
32505 PyObject * obj0 = 0 ;
32506 PyObject * obj1 = 0 ;
32507 PyObject * obj2 = 0 ;
32508 PyObject * obj3 = 0 ;
32509 char * kwnames[] = {
32510 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32511 };
32512
32513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32515 if (!SWIG_IsOK(res1)) {
32516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32517 }
32518 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32519 arg2 = obj1;
32520 arg3 = obj2;
32521 ecode4 = SWIG_AsVal_int(obj3, &val4);
32522 if (!SWIG_IsOK(ecode4)) {
32523 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32524 }
32525 arg4 = static_cast< int >(val4);
32526 {
32527 PyThreadState* __tstate = wxPyBeginAllowThreads();
32528 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32529 wxPyEndAllowThreads(__tstate);
32530 if (PyErr_Occurred()) SWIG_fail;
32531 }
32532 resultobj = SWIG_Py_Void();
32533 return resultobj;
32534 fail:
32535 return NULL;
32536 }
32537
32538
32539 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32540 PyObject *resultobj = 0;
32541 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32542 void *argp1 = 0 ;
32543 int res1 = 0 ;
32544 PyObject *swig_obj[1] ;
32545
32546 if (!args) SWIG_fail;
32547 swig_obj[0] = args;
32548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32549 if (!SWIG_IsOK(res1)) {
32550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32551 }
32552 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32553 {
32554 PyThreadState* __tstate = wxPyBeginAllowThreads();
32555 delete arg1;
32556
32557 wxPyEndAllowThreads(__tstate);
32558 if (PyErr_Occurred()) SWIG_fail;
32559 }
32560 resultobj = SWIG_Py_Void();
32561 return resultobj;
32562 fail:
32563 return NULL;
32564 }
32565
32566
32567 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32568 PyObject *resultobj = 0;
32569 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32570 wxDataObject *arg2 = 0 ;
32571 void *argp1 = 0 ;
32572 int res1 = 0 ;
32573 void *argp2 = 0 ;
32574 int res2 = 0 ;
32575 PyObject * obj0 = 0 ;
32576 PyObject * obj1 = 0 ;
32577 char * kwnames[] = {
32578 (char *) "self",(char *) "data", NULL
32579 };
32580
32581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32583 if (!SWIG_IsOK(res1)) {
32584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32585 }
32586 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32587 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32588 if (!SWIG_IsOK(res2)) {
32589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32590 }
32591 if (!argp2) {
32592 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32593 }
32594 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32595 {
32596 PyThreadState* __tstate = wxPyBeginAllowThreads();
32597 (arg1)->SetData(*arg2);
32598 wxPyEndAllowThreads(__tstate);
32599 if (PyErr_Occurred()) SWIG_fail;
32600 }
32601 resultobj = SWIG_Py_Void();
32602 return resultobj;
32603 fail:
32604 return NULL;
32605 }
32606
32607
32608 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32609 PyObject *resultobj = 0;
32610 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32611 wxDataObject *result = 0 ;
32612 void *argp1 = 0 ;
32613 int res1 = 0 ;
32614 PyObject *swig_obj[1] ;
32615
32616 if (!args) SWIG_fail;
32617 swig_obj[0] = args;
32618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32619 if (!SWIG_IsOK(res1)) {
32620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32621 }
32622 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32623 {
32624 PyThreadState* __tstate = wxPyBeginAllowThreads();
32625 result = (wxDataObject *)(arg1)->GetDataObject();
32626 wxPyEndAllowThreads(__tstate);
32627 if (PyErr_Occurred()) SWIG_fail;
32628 }
32629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32637 PyObject *resultobj = 0;
32638 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32639 wxDragResult arg2 ;
32640 wxCursor *arg3 = 0 ;
32641 void *argp1 = 0 ;
32642 int res1 = 0 ;
32643 int val2 ;
32644 int ecode2 = 0 ;
32645 void *argp3 = 0 ;
32646 int res3 = 0 ;
32647 PyObject * obj0 = 0 ;
32648 PyObject * obj1 = 0 ;
32649 PyObject * obj2 = 0 ;
32650 char * kwnames[] = {
32651 (char *) "self",(char *) "res",(char *) "cursor", NULL
32652 };
32653
32654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32656 if (!SWIG_IsOK(res1)) {
32657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32658 }
32659 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32660 ecode2 = SWIG_AsVal_int(obj1, &val2);
32661 if (!SWIG_IsOK(ecode2)) {
32662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32663 }
32664 arg2 = static_cast< wxDragResult >(val2);
32665 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32666 if (!SWIG_IsOK(res3)) {
32667 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32668 }
32669 if (!argp3) {
32670 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32671 }
32672 arg3 = reinterpret_cast< wxCursor * >(argp3);
32673 {
32674 PyThreadState* __tstate = wxPyBeginAllowThreads();
32675 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32676 wxPyEndAllowThreads(__tstate);
32677 if (PyErr_Occurred()) SWIG_fail;
32678 }
32679 resultobj = SWIG_Py_Void();
32680 return resultobj;
32681 fail:
32682 return NULL;
32683 }
32684
32685
32686 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32687 PyObject *resultobj = 0;
32688 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32689 int arg2 = (int) wxDrag_CopyOnly ;
32690 wxDragResult result;
32691 void *argp1 = 0 ;
32692 int res1 = 0 ;
32693 int val2 ;
32694 int ecode2 = 0 ;
32695 PyObject * obj0 = 0 ;
32696 PyObject * obj1 = 0 ;
32697 char * kwnames[] = {
32698 (char *) "self",(char *) "flags", NULL
32699 };
32700
32701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32705 }
32706 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32707 if (obj1) {
32708 ecode2 = SWIG_AsVal_int(obj1, &val2);
32709 if (!SWIG_IsOK(ecode2)) {
32710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32711 }
32712 arg2 = static_cast< int >(val2);
32713 }
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 resultobj = SWIG_From_int(static_cast< int >(result));
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32728 PyObject *resultobj = 0;
32729 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32730 wxDragResult arg2 ;
32731 bool result;
32732 void *argp1 = 0 ;
32733 int res1 = 0 ;
32734 int val2 ;
32735 int ecode2 = 0 ;
32736 PyObject * obj0 = 0 ;
32737 PyObject * obj1 = 0 ;
32738 char * kwnames[] = {
32739 (char *) "self",(char *) "effect", NULL
32740 };
32741
32742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32744 if (!SWIG_IsOK(res1)) {
32745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32746 }
32747 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32748 ecode2 = SWIG_AsVal_int(obj1, &val2);
32749 if (!SWIG_IsOK(ecode2)) {
32750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32751 }
32752 arg2 = static_cast< wxDragResult >(val2);
32753 {
32754 PyThreadState* __tstate = wxPyBeginAllowThreads();
32755 result = (bool)(arg1)->GiveFeedback(arg2);
32756 wxPyEndAllowThreads(__tstate);
32757 if (PyErr_Occurred()) SWIG_fail;
32758 }
32759 {
32760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32761 }
32762 return resultobj;
32763 fail:
32764 return NULL;
32765 }
32766
32767
32768 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32769 PyObject *obj;
32770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32771 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32772 return SWIG_Py_Void();
32773 }
32774
32775 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32776 return SWIG_Python_InitShadowInstance(args);
32777 }
32778
32779 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32780 PyObject *resultobj = 0;
32781 wxDataObject *arg1 = (wxDataObject *) NULL ;
32782 wxPyDropTarget *result = 0 ;
32783 int res1 = 0 ;
32784 PyObject * obj0 = 0 ;
32785 char * kwnames[] = {
32786 (char *) "dataObject", NULL
32787 };
32788
32789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32790 if (obj0) {
32791 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32792 if (!SWIG_IsOK(res1)) {
32793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32794 }
32795 }
32796 {
32797 PyThreadState* __tstate = wxPyBeginAllowThreads();
32798 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32799 wxPyEndAllowThreads(__tstate);
32800 if (PyErr_Occurred()) SWIG_fail;
32801 }
32802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32803 return resultobj;
32804 fail:
32805 return NULL;
32806 }
32807
32808
32809 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32810 PyObject *resultobj = 0;
32811 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32812 PyObject *arg2 = (PyObject *) 0 ;
32813 PyObject *arg3 = (PyObject *) 0 ;
32814 void *argp1 = 0 ;
32815 int res1 = 0 ;
32816 PyObject * obj0 = 0 ;
32817 PyObject * obj1 = 0 ;
32818 PyObject * obj2 = 0 ;
32819 char * kwnames[] = {
32820 (char *) "self",(char *) "self",(char *) "_class", NULL
32821 };
32822
32823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32825 if (!SWIG_IsOK(res1)) {
32826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32827 }
32828 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32829 arg2 = obj1;
32830 arg3 = obj2;
32831 {
32832 PyThreadState* __tstate = wxPyBeginAllowThreads();
32833 (arg1)->_setCallbackInfo(arg2,arg3);
32834 wxPyEndAllowThreads(__tstate);
32835 if (PyErr_Occurred()) SWIG_fail;
32836 }
32837 resultobj = SWIG_Py_Void();
32838 return resultobj;
32839 fail:
32840 return NULL;
32841 }
32842
32843
32844 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32845 PyObject *resultobj = 0;
32846 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32847 void *argp1 = 0 ;
32848 int res1 = 0 ;
32849 PyObject *swig_obj[1] ;
32850
32851 if (!args) SWIG_fail;
32852 swig_obj[0] = args;
32853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32854 if (!SWIG_IsOK(res1)) {
32855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32856 }
32857 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32858 {
32859 PyThreadState* __tstate = wxPyBeginAllowThreads();
32860 delete arg1;
32861
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 resultobj = SWIG_Py_Void();
32866 return resultobj;
32867 fail:
32868 return NULL;
32869 }
32870
32871
32872 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32873 PyObject *resultobj = 0;
32874 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32875 wxDataObject *result = 0 ;
32876 void *argp1 = 0 ;
32877 int res1 = 0 ;
32878 PyObject *swig_obj[1] ;
32879
32880 if (!args) SWIG_fail;
32881 swig_obj[0] = args;
32882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32883 if (!SWIG_IsOK(res1)) {
32884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32885 }
32886 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32887 {
32888 PyThreadState* __tstate = wxPyBeginAllowThreads();
32889 result = (wxDataObject *)(arg1)->GetDataObject();
32890 wxPyEndAllowThreads(__tstate);
32891 if (PyErr_Occurred()) SWIG_fail;
32892 }
32893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32894 return resultobj;
32895 fail:
32896 return NULL;
32897 }
32898
32899
32900 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32901 PyObject *resultobj = 0;
32902 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32903 wxDataObject *arg2 = (wxDataObject *) 0 ;
32904 void *argp1 = 0 ;
32905 int res1 = 0 ;
32906 int res2 = 0 ;
32907 PyObject * obj0 = 0 ;
32908 PyObject * obj1 = 0 ;
32909 char * kwnames[] = {
32910 (char *) "self",(char *) "dataObject", NULL
32911 };
32912
32913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32917 }
32918 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32919 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32920 if (!SWIG_IsOK(res2)) {
32921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32922 }
32923 {
32924 PyThreadState* __tstate = wxPyBeginAllowThreads();
32925 (arg1)->SetDataObject(arg2);
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 resultobj = SWIG_Py_Void();
32930 return resultobj;
32931 fail:
32932 return NULL;
32933 }
32934
32935
32936 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32937 PyObject *resultobj = 0;
32938 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32939 int arg2 ;
32940 int arg3 ;
32941 wxDragResult arg4 ;
32942 wxDragResult result;
32943 void *argp1 = 0 ;
32944 int res1 = 0 ;
32945 int val2 ;
32946 int ecode2 = 0 ;
32947 int val3 ;
32948 int ecode3 = 0 ;
32949 int val4 ;
32950 int ecode4 = 0 ;
32951 PyObject * obj0 = 0 ;
32952 PyObject * obj1 = 0 ;
32953 PyObject * obj2 = 0 ;
32954 PyObject * obj3 = 0 ;
32955 char * kwnames[] = {
32956 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32957 };
32958
32959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32961 if (!SWIG_IsOK(res1)) {
32962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32963 }
32964 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32965 ecode2 = SWIG_AsVal_int(obj1, &val2);
32966 if (!SWIG_IsOK(ecode2)) {
32967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32968 }
32969 arg2 = static_cast< int >(val2);
32970 ecode3 = SWIG_AsVal_int(obj2, &val3);
32971 if (!SWIG_IsOK(ecode3)) {
32972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32973 }
32974 arg3 = static_cast< int >(val3);
32975 ecode4 = SWIG_AsVal_int(obj3, &val4);
32976 if (!SWIG_IsOK(ecode4)) {
32977 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32978 }
32979 arg4 = static_cast< wxDragResult >(val4);
32980 {
32981 PyThreadState* __tstate = wxPyBeginAllowThreads();
32982 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32983 wxPyEndAllowThreads(__tstate);
32984 if (PyErr_Occurred()) SWIG_fail;
32985 }
32986 resultobj = SWIG_From_int(static_cast< int >(result));
32987 return resultobj;
32988 fail:
32989 return NULL;
32990 }
32991
32992
32993 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32994 PyObject *resultobj = 0;
32995 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32996 int arg2 ;
32997 int arg3 ;
32998 wxDragResult arg4 ;
32999 wxDragResult result;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 int val2 ;
33003 int ecode2 = 0 ;
33004 int val3 ;
33005 int ecode3 = 0 ;
33006 int val4 ;
33007 int ecode4 = 0 ;
33008 PyObject * obj0 = 0 ;
33009 PyObject * obj1 = 0 ;
33010 PyObject * obj2 = 0 ;
33011 PyObject * obj3 = 0 ;
33012 char * kwnames[] = {
33013 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33014 };
33015
33016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33018 if (!SWIG_IsOK(res1)) {
33019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33020 }
33021 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33022 ecode2 = SWIG_AsVal_int(obj1, &val2);
33023 if (!SWIG_IsOK(ecode2)) {
33024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33025 }
33026 arg2 = static_cast< int >(val2);
33027 ecode3 = SWIG_AsVal_int(obj2, &val3);
33028 if (!SWIG_IsOK(ecode3)) {
33029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33030 }
33031 arg3 = static_cast< int >(val3);
33032 ecode4 = SWIG_AsVal_int(obj3, &val4);
33033 if (!SWIG_IsOK(ecode4)) {
33034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33035 }
33036 arg4 = static_cast< wxDragResult >(val4);
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 resultobj = SWIG_From_int(static_cast< int >(result));
33044 return resultobj;
33045 fail:
33046 return NULL;
33047 }
33048
33049
33050 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33051 PyObject *resultobj = 0;
33052 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33053 void *argp1 = 0 ;
33054 int res1 = 0 ;
33055 PyObject *swig_obj[1] ;
33056
33057 if (!args) SWIG_fail;
33058 swig_obj[0] = args;
33059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33060 if (!SWIG_IsOK(res1)) {
33061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33062 }
33063 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33064 {
33065 PyThreadState* __tstate = wxPyBeginAllowThreads();
33066 (arg1)->OnLeave();
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 resultobj = SWIG_Py_Void();
33071 return resultobj;
33072 fail:
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33078 PyObject *resultobj = 0;
33079 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33080 int arg2 ;
33081 int arg3 ;
33082 bool result;
33083 void *argp1 = 0 ;
33084 int res1 = 0 ;
33085 int val2 ;
33086 int ecode2 = 0 ;
33087 int val3 ;
33088 int ecode3 = 0 ;
33089 PyObject * obj0 = 0 ;
33090 PyObject * obj1 = 0 ;
33091 PyObject * obj2 = 0 ;
33092 char * kwnames[] = {
33093 (char *) "self",(char *) "x",(char *) "y", NULL
33094 };
33095
33096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33098 if (!SWIG_IsOK(res1)) {
33099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33100 }
33101 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33102 ecode2 = SWIG_AsVal_int(obj1, &val2);
33103 if (!SWIG_IsOK(ecode2)) {
33104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33105 }
33106 arg2 = static_cast< int >(val2);
33107 ecode3 = SWIG_AsVal_int(obj2, &val3);
33108 if (!SWIG_IsOK(ecode3)) {
33109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33110 }
33111 arg3 = static_cast< int >(val3);
33112 {
33113 PyThreadState* __tstate = wxPyBeginAllowThreads();
33114 result = (bool)(arg1)->OnDrop(arg2,arg3);
33115 wxPyEndAllowThreads(__tstate);
33116 if (PyErr_Occurred()) SWIG_fail;
33117 }
33118 {
33119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33120 }
33121 return resultobj;
33122 fail:
33123 return NULL;
33124 }
33125
33126
33127 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33128 PyObject *resultobj = 0;
33129 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33130 bool result;
33131 void *argp1 = 0 ;
33132 int res1 = 0 ;
33133 PyObject *swig_obj[1] ;
33134
33135 if (!args) SWIG_fail;
33136 swig_obj[0] = args;
33137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33138 if (!SWIG_IsOK(res1)) {
33139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33140 }
33141 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33142 {
33143 PyThreadState* __tstate = wxPyBeginAllowThreads();
33144 result = (bool)(arg1)->GetData();
33145 wxPyEndAllowThreads(__tstate);
33146 if (PyErr_Occurred()) SWIG_fail;
33147 }
33148 {
33149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33150 }
33151 return resultobj;
33152 fail:
33153 return NULL;
33154 }
33155
33156
33157 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33158 PyObject *resultobj = 0;
33159 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33160 wxDragResult arg2 ;
33161 void *argp1 = 0 ;
33162 int res1 = 0 ;
33163 int val2 ;
33164 int ecode2 = 0 ;
33165 PyObject * obj0 = 0 ;
33166 PyObject * obj1 = 0 ;
33167 char * kwnames[] = {
33168 (char *) "self",(char *) "action", NULL
33169 };
33170
33171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33173 if (!SWIG_IsOK(res1)) {
33174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33175 }
33176 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33177 ecode2 = SWIG_AsVal_int(obj1, &val2);
33178 if (!SWIG_IsOK(ecode2)) {
33179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33180 }
33181 arg2 = static_cast< wxDragResult >(val2);
33182 {
33183 PyThreadState* __tstate = wxPyBeginAllowThreads();
33184 (arg1)->SetDefaultAction(arg2);
33185 wxPyEndAllowThreads(__tstate);
33186 if (PyErr_Occurred()) SWIG_fail;
33187 }
33188 resultobj = SWIG_Py_Void();
33189 return resultobj;
33190 fail:
33191 return NULL;
33192 }
33193
33194
33195 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33196 PyObject *resultobj = 0;
33197 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33198 wxDragResult result;
33199 void *argp1 = 0 ;
33200 int res1 = 0 ;
33201 PyObject *swig_obj[1] ;
33202
33203 if (!args) SWIG_fail;
33204 swig_obj[0] = args;
33205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33206 if (!SWIG_IsOK(res1)) {
33207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33208 }
33209 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33210 {
33211 PyThreadState* __tstate = wxPyBeginAllowThreads();
33212 result = (wxDragResult)(arg1)->GetDefaultAction();
33213 wxPyEndAllowThreads(__tstate);
33214 if (PyErr_Occurred()) SWIG_fail;
33215 }
33216 resultobj = SWIG_From_int(static_cast< int >(result));
33217 return resultobj;
33218 fail:
33219 return NULL;
33220 }
33221
33222
33223 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33224 PyObject *obj;
33225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33226 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33227 return SWIG_Py_Void();
33228 }
33229
33230 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33231 return SWIG_Python_InitShadowInstance(args);
33232 }
33233
33234 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33235 PyObject *resultobj = 0;
33236 wxPyTextDropTarget *result = 0 ;
33237
33238 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33239 {
33240 PyThreadState* __tstate = wxPyBeginAllowThreads();
33241 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33242 wxPyEndAllowThreads(__tstate);
33243 if (PyErr_Occurred()) SWIG_fail;
33244 }
33245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33246 return resultobj;
33247 fail:
33248 return NULL;
33249 }
33250
33251
33252 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33253 PyObject *resultobj = 0;
33254 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33255 PyObject *arg2 = (PyObject *) 0 ;
33256 PyObject *arg3 = (PyObject *) 0 ;
33257 void *argp1 = 0 ;
33258 int res1 = 0 ;
33259 PyObject * obj0 = 0 ;
33260 PyObject * obj1 = 0 ;
33261 PyObject * obj2 = 0 ;
33262 char * kwnames[] = {
33263 (char *) "self",(char *) "self",(char *) "_class", NULL
33264 };
33265
33266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33268 if (!SWIG_IsOK(res1)) {
33269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33270 }
33271 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33272 arg2 = obj1;
33273 arg3 = obj2;
33274 {
33275 PyThreadState* __tstate = wxPyBeginAllowThreads();
33276 (arg1)->_setCallbackInfo(arg2,arg3);
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 resultobj = SWIG_Py_Void();
33281 return resultobj;
33282 fail:
33283 return NULL;
33284 }
33285
33286
33287 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33288 PyObject *resultobj = 0;
33289 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33290 int arg2 ;
33291 int arg3 ;
33292 wxString *arg4 = 0 ;
33293 bool result;
33294 void *argp1 = 0 ;
33295 int res1 = 0 ;
33296 int val2 ;
33297 int ecode2 = 0 ;
33298 int val3 ;
33299 int ecode3 = 0 ;
33300 bool temp4 = false ;
33301 PyObject * obj0 = 0 ;
33302 PyObject * obj1 = 0 ;
33303 PyObject * obj2 = 0 ;
33304 PyObject * obj3 = 0 ;
33305 char * kwnames[] = {
33306 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33307 };
33308
33309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33311 if (!SWIG_IsOK(res1)) {
33312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33313 }
33314 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33315 ecode2 = SWIG_AsVal_int(obj1, &val2);
33316 if (!SWIG_IsOK(ecode2)) {
33317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33318 }
33319 arg2 = static_cast< int >(val2);
33320 ecode3 = SWIG_AsVal_int(obj2, &val3);
33321 if (!SWIG_IsOK(ecode3)) {
33322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33323 }
33324 arg3 = static_cast< int >(val3);
33325 {
33326 arg4 = wxString_in_helper(obj3);
33327 if (arg4 == NULL) SWIG_fail;
33328 temp4 = true;
33329 }
33330 {
33331 PyThreadState* __tstate = wxPyBeginAllowThreads();
33332 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33333 wxPyEndAllowThreads(__tstate);
33334 if (PyErr_Occurred()) SWIG_fail;
33335 }
33336 {
33337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33338 }
33339 {
33340 if (temp4)
33341 delete arg4;
33342 }
33343 return resultobj;
33344 fail:
33345 {
33346 if (temp4)
33347 delete arg4;
33348 }
33349 return NULL;
33350 }
33351
33352
33353 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33354 PyObject *resultobj = 0;
33355 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33356 int arg2 ;
33357 int arg3 ;
33358 wxDragResult arg4 ;
33359 wxDragResult result;
33360 void *argp1 = 0 ;
33361 int res1 = 0 ;
33362 int val2 ;
33363 int ecode2 = 0 ;
33364 int val3 ;
33365 int ecode3 = 0 ;
33366 int val4 ;
33367 int ecode4 = 0 ;
33368 PyObject * obj0 = 0 ;
33369 PyObject * obj1 = 0 ;
33370 PyObject * obj2 = 0 ;
33371 PyObject * obj3 = 0 ;
33372 char * kwnames[] = {
33373 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33374 };
33375
33376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33378 if (!SWIG_IsOK(res1)) {
33379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33380 }
33381 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33382 ecode2 = SWIG_AsVal_int(obj1, &val2);
33383 if (!SWIG_IsOK(ecode2)) {
33384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33385 }
33386 arg2 = static_cast< int >(val2);
33387 ecode3 = SWIG_AsVal_int(obj2, &val3);
33388 if (!SWIG_IsOK(ecode3)) {
33389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33390 }
33391 arg3 = static_cast< int >(val3);
33392 ecode4 = SWIG_AsVal_int(obj3, &val4);
33393 if (!SWIG_IsOK(ecode4)) {
33394 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33395 }
33396 arg4 = static_cast< wxDragResult >(val4);
33397 {
33398 PyThreadState* __tstate = wxPyBeginAllowThreads();
33399 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 resultobj = SWIG_From_int(static_cast< int >(result));
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33411 PyObject *resultobj = 0;
33412 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33413 int arg2 ;
33414 int arg3 ;
33415 wxDragResult arg4 ;
33416 wxDragResult result;
33417 void *argp1 = 0 ;
33418 int res1 = 0 ;
33419 int val2 ;
33420 int ecode2 = 0 ;
33421 int val3 ;
33422 int ecode3 = 0 ;
33423 int val4 ;
33424 int ecode4 = 0 ;
33425 PyObject * obj0 = 0 ;
33426 PyObject * obj1 = 0 ;
33427 PyObject * obj2 = 0 ;
33428 PyObject * obj3 = 0 ;
33429 char * kwnames[] = {
33430 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33431 };
33432
33433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33435 if (!SWIG_IsOK(res1)) {
33436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33437 }
33438 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33439 ecode2 = SWIG_AsVal_int(obj1, &val2);
33440 if (!SWIG_IsOK(ecode2)) {
33441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33442 }
33443 arg2 = static_cast< int >(val2);
33444 ecode3 = SWIG_AsVal_int(obj2, &val3);
33445 if (!SWIG_IsOK(ecode3)) {
33446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33447 }
33448 arg3 = static_cast< int >(val3);
33449 ecode4 = SWIG_AsVal_int(obj3, &val4);
33450 if (!SWIG_IsOK(ecode4)) {
33451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33452 }
33453 arg4 = static_cast< wxDragResult >(val4);
33454 {
33455 PyThreadState* __tstate = wxPyBeginAllowThreads();
33456 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33457 wxPyEndAllowThreads(__tstate);
33458 if (PyErr_Occurred()) SWIG_fail;
33459 }
33460 resultobj = SWIG_From_int(static_cast< int >(result));
33461 return resultobj;
33462 fail:
33463 return NULL;
33464 }
33465
33466
33467 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33468 PyObject *resultobj = 0;
33469 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33470 void *argp1 = 0 ;
33471 int res1 = 0 ;
33472 PyObject *swig_obj[1] ;
33473
33474 if (!args) SWIG_fail;
33475 swig_obj[0] = args;
33476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33477 if (!SWIG_IsOK(res1)) {
33478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33479 }
33480 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33481 {
33482 PyThreadState* __tstate = wxPyBeginAllowThreads();
33483 (arg1)->OnLeave();
33484 wxPyEndAllowThreads(__tstate);
33485 if (PyErr_Occurred()) SWIG_fail;
33486 }
33487 resultobj = SWIG_Py_Void();
33488 return resultobj;
33489 fail:
33490 return NULL;
33491 }
33492
33493
33494 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33495 PyObject *resultobj = 0;
33496 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33497 int arg2 ;
33498 int arg3 ;
33499 bool result;
33500 void *argp1 = 0 ;
33501 int res1 = 0 ;
33502 int val2 ;
33503 int ecode2 = 0 ;
33504 int val3 ;
33505 int ecode3 = 0 ;
33506 PyObject * obj0 = 0 ;
33507 PyObject * obj1 = 0 ;
33508 PyObject * obj2 = 0 ;
33509 char * kwnames[] = {
33510 (char *) "self",(char *) "x",(char *) "y", NULL
33511 };
33512
33513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33515 if (!SWIG_IsOK(res1)) {
33516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33517 }
33518 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33519 ecode2 = SWIG_AsVal_int(obj1, &val2);
33520 if (!SWIG_IsOK(ecode2)) {
33521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33522 }
33523 arg2 = static_cast< int >(val2);
33524 ecode3 = SWIG_AsVal_int(obj2, &val3);
33525 if (!SWIG_IsOK(ecode3)) {
33526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33527 }
33528 arg3 = static_cast< int >(val3);
33529 {
33530 PyThreadState* __tstate = wxPyBeginAllowThreads();
33531 result = (bool)(arg1)->OnDrop(arg2,arg3);
33532 wxPyEndAllowThreads(__tstate);
33533 if (PyErr_Occurred()) SWIG_fail;
33534 }
33535 {
33536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33537 }
33538 return resultobj;
33539 fail:
33540 return NULL;
33541 }
33542
33543
33544 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33545 PyObject *resultobj = 0;
33546 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33547 int arg2 ;
33548 int arg3 ;
33549 wxDragResult arg4 ;
33550 wxDragResult result;
33551 void *argp1 = 0 ;
33552 int res1 = 0 ;
33553 int val2 ;
33554 int ecode2 = 0 ;
33555 int val3 ;
33556 int ecode3 = 0 ;
33557 int val4 ;
33558 int ecode4 = 0 ;
33559 PyObject * obj0 = 0 ;
33560 PyObject * obj1 = 0 ;
33561 PyObject * obj2 = 0 ;
33562 PyObject * obj3 = 0 ;
33563 char * kwnames[] = {
33564 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33565 };
33566
33567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33569 if (!SWIG_IsOK(res1)) {
33570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33571 }
33572 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33573 ecode2 = SWIG_AsVal_int(obj1, &val2);
33574 if (!SWIG_IsOK(ecode2)) {
33575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33576 }
33577 arg2 = static_cast< int >(val2);
33578 ecode3 = SWIG_AsVal_int(obj2, &val3);
33579 if (!SWIG_IsOK(ecode3)) {
33580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33581 }
33582 arg3 = static_cast< int >(val3);
33583 ecode4 = SWIG_AsVal_int(obj3, &val4);
33584 if (!SWIG_IsOK(ecode4)) {
33585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33586 }
33587 arg4 = static_cast< wxDragResult >(val4);
33588 {
33589 PyThreadState* __tstate = wxPyBeginAllowThreads();
33590 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33591 wxPyEndAllowThreads(__tstate);
33592 if (PyErr_Occurred()) SWIG_fail;
33593 }
33594 resultobj = SWIG_From_int(static_cast< int >(result));
33595 return resultobj;
33596 fail:
33597 return NULL;
33598 }
33599
33600
33601 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33602 PyObject *obj;
33603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33604 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33605 return SWIG_Py_Void();
33606 }
33607
33608 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33609 return SWIG_Python_InitShadowInstance(args);
33610 }
33611
33612 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33613 PyObject *resultobj = 0;
33614 wxPyFileDropTarget *result = 0 ;
33615
33616 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33620 wxPyEndAllowThreads(__tstate);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 }
33623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33624 return resultobj;
33625 fail:
33626 return NULL;
33627 }
33628
33629
33630 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33631 PyObject *resultobj = 0;
33632 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33633 PyObject *arg2 = (PyObject *) 0 ;
33634 PyObject *arg3 = (PyObject *) 0 ;
33635 void *argp1 = 0 ;
33636 int res1 = 0 ;
33637 PyObject * obj0 = 0 ;
33638 PyObject * obj1 = 0 ;
33639 PyObject * obj2 = 0 ;
33640 char * kwnames[] = {
33641 (char *) "self",(char *) "self",(char *) "_class", NULL
33642 };
33643
33644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33646 if (!SWIG_IsOK(res1)) {
33647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33648 }
33649 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33650 arg2 = obj1;
33651 arg3 = obj2;
33652 {
33653 PyThreadState* __tstate = wxPyBeginAllowThreads();
33654 (arg1)->_setCallbackInfo(arg2,arg3);
33655 wxPyEndAllowThreads(__tstate);
33656 if (PyErr_Occurred()) SWIG_fail;
33657 }
33658 resultobj = SWIG_Py_Void();
33659 return resultobj;
33660 fail:
33661 return NULL;
33662 }
33663
33664
33665 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33666 PyObject *resultobj = 0;
33667 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33668 int arg2 ;
33669 int arg3 ;
33670 wxArrayString *arg4 = 0 ;
33671 bool result;
33672 void *argp1 = 0 ;
33673 int res1 = 0 ;
33674 int val2 ;
33675 int ecode2 = 0 ;
33676 int val3 ;
33677 int ecode3 = 0 ;
33678 bool temp4 = false ;
33679 PyObject * obj0 = 0 ;
33680 PyObject * obj1 = 0 ;
33681 PyObject * obj2 = 0 ;
33682 PyObject * obj3 = 0 ;
33683 char * kwnames[] = {
33684 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33685 };
33686
33687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33689 if (!SWIG_IsOK(res1)) {
33690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33691 }
33692 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33693 ecode2 = SWIG_AsVal_int(obj1, &val2);
33694 if (!SWIG_IsOK(ecode2)) {
33695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33696 }
33697 arg2 = static_cast< int >(val2);
33698 ecode3 = SWIG_AsVal_int(obj2, &val3);
33699 if (!SWIG_IsOK(ecode3)) {
33700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33701 }
33702 arg3 = static_cast< int >(val3);
33703 {
33704 if (! PySequence_Check(obj3)) {
33705 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33706 SWIG_fail;
33707 }
33708 arg4 = new wxArrayString;
33709 temp4 = true;
33710 int i, len=PySequence_Length(obj3);
33711 for (i=0; i<len; i++) {
33712 PyObject* item = PySequence_GetItem(obj3, i);
33713 wxString* s = wxString_in_helper(item);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 arg4->Add(*s);
33716 delete s;
33717 Py_DECREF(item);
33718 }
33719 }
33720 {
33721 PyThreadState* __tstate = wxPyBeginAllowThreads();
33722 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33723 wxPyEndAllowThreads(__tstate);
33724 if (PyErr_Occurred()) SWIG_fail;
33725 }
33726 {
33727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33728 }
33729 {
33730 if (temp4) delete arg4;
33731 }
33732 return resultobj;
33733 fail:
33734 {
33735 if (temp4) delete arg4;
33736 }
33737 return NULL;
33738 }
33739
33740
33741 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33742 PyObject *resultobj = 0;
33743 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33744 int arg2 ;
33745 int arg3 ;
33746 wxDragResult arg4 ;
33747 wxDragResult result;
33748 void *argp1 = 0 ;
33749 int res1 = 0 ;
33750 int val2 ;
33751 int ecode2 = 0 ;
33752 int val3 ;
33753 int ecode3 = 0 ;
33754 int val4 ;
33755 int ecode4 = 0 ;
33756 PyObject * obj0 = 0 ;
33757 PyObject * obj1 = 0 ;
33758 PyObject * obj2 = 0 ;
33759 PyObject * obj3 = 0 ;
33760 char * kwnames[] = {
33761 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33762 };
33763
33764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33766 if (!SWIG_IsOK(res1)) {
33767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33768 }
33769 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33770 ecode2 = SWIG_AsVal_int(obj1, &val2);
33771 if (!SWIG_IsOK(ecode2)) {
33772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33773 }
33774 arg2 = static_cast< int >(val2);
33775 ecode3 = SWIG_AsVal_int(obj2, &val3);
33776 if (!SWIG_IsOK(ecode3)) {
33777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33778 }
33779 arg3 = static_cast< int >(val3);
33780 ecode4 = SWIG_AsVal_int(obj3, &val4);
33781 if (!SWIG_IsOK(ecode4)) {
33782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33783 }
33784 arg4 = static_cast< wxDragResult >(val4);
33785 {
33786 PyThreadState* __tstate = wxPyBeginAllowThreads();
33787 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 resultobj = SWIG_From_int(static_cast< int >(result));
33792 return resultobj;
33793 fail:
33794 return NULL;
33795 }
33796
33797
33798 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33799 PyObject *resultobj = 0;
33800 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33801 int arg2 ;
33802 int arg3 ;
33803 wxDragResult arg4 ;
33804 wxDragResult result;
33805 void *argp1 = 0 ;
33806 int res1 = 0 ;
33807 int val2 ;
33808 int ecode2 = 0 ;
33809 int val3 ;
33810 int ecode3 = 0 ;
33811 int val4 ;
33812 int ecode4 = 0 ;
33813 PyObject * obj0 = 0 ;
33814 PyObject * obj1 = 0 ;
33815 PyObject * obj2 = 0 ;
33816 PyObject * obj3 = 0 ;
33817 char * kwnames[] = {
33818 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33819 };
33820
33821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33823 if (!SWIG_IsOK(res1)) {
33824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33825 }
33826 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33827 ecode2 = SWIG_AsVal_int(obj1, &val2);
33828 if (!SWIG_IsOK(ecode2)) {
33829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33830 }
33831 arg2 = static_cast< int >(val2);
33832 ecode3 = SWIG_AsVal_int(obj2, &val3);
33833 if (!SWIG_IsOK(ecode3)) {
33834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33835 }
33836 arg3 = static_cast< int >(val3);
33837 ecode4 = SWIG_AsVal_int(obj3, &val4);
33838 if (!SWIG_IsOK(ecode4)) {
33839 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33840 }
33841 arg4 = static_cast< wxDragResult >(val4);
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33845 wxPyEndAllowThreads(__tstate);
33846 if (PyErr_Occurred()) SWIG_fail;
33847 }
33848 resultobj = SWIG_From_int(static_cast< int >(result));
33849 return resultobj;
33850 fail:
33851 return NULL;
33852 }
33853
33854
33855 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33856 PyObject *resultobj = 0;
33857 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 PyObject *swig_obj[1] ;
33861
33862 if (!args) SWIG_fail;
33863 swig_obj[0] = args;
33864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33865 if (!SWIG_IsOK(res1)) {
33866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33867 }
33868 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 (arg1)->OnLeave();
33872 wxPyEndAllowThreads(__tstate);
33873 if (PyErr_Occurred()) SWIG_fail;
33874 }
33875 resultobj = SWIG_Py_Void();
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj = 0;
33884 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33885 int arg2 ;
33886 int arg3 ;
33887 bool result;
33888 void *argp1 = 0 ;
33889 int res1 = 0 ;
33890 int val2 ;
33891 int ecode2 = 0 ;
33892 int val3 ;
33893 int ecode3 = 0 ;
33894 PyObject * obj0 = 0 ;
33895 PyObject * obj1 = 0 ;
33896 PyObject * obj2 = 0 ;
33897 char * kwnames[] = {
33898 (char *) "self",(char *) "x",(char *) "y", NULL
33899 };
33900
33901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33903 if (!SWIG_IsOK(res1)) {
33904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33905 }
33906 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33907 ecode2 = SWIG_AsVal_int(obj1, &val2);
33908 if (!SWIG_IsOK(ecode2)) {
33909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33910 }
33911 arg2 = static_cast< int >(val2);
33912 ecode3 = SWIG_AsVal_int(obj2, &val3);
33913 if (!SWIG_IsOK(ecode3)) {
33914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33915 }
33916 arg3 = static_cast< int >(val3);
33917 {
33918 PyThreadState* __tstate = wxPyBeginAllowThreads();
33919 result = (bool)(arg1)->OnDrop(arg2,arg3);
33920 wxPyEndAllowThreads(__tstate);
33921 if (PyErr_Occurred()) SWIG_fail;
33922 }
33923 {
33924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33925 }
33926 return resultobj;
33927 fail:
33928 return NULL;
33929 }
33930
33931
33932 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33933 PyObject *resultobj = 0;
33934 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33935 int arg2 ;
33936 int arg3 ;
33937 wxDragResult arg4 ;
33938 wxDragResult result;
33939 void *argp1 = 0 ;
33940 int res1 = 0 ;
33941 int val2 ;
33942 int ecode2 = 0 ;
33943 int val3 ;
33944 int ecode3 = 0 ;
33945 int val4 ;
33946 int ecode4 = 0 ;
33947 PyObject * obj0 = 0 ;
33948 PyObject * obj1 = 0 ;
33949 PyObject * obj2 = 0 ;
33950 PyObject * obj3 = 0 ;
33951 char * kwnames[] = {
33952 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33953 };
33954
33955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33957 if (!SWIG_IsOK(res1)) {
33958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33959 }
33960 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33961 ecode2 = SWIG_AsVal_int(obj1, &val2);
33962 if (!SWIG_IsOK(ecode2)) {
33963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33964 }
33965 arg2 = static_cast< int >(val2);
33966 ecode3 = SWIG_AsVal_int(obj2, &val3);
33967 if (!SWIG_IsOK(ecode3)) {
33968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33969 }
33970 arg3 = static_cast< int >(val3);
33971 ecode4 = SWIG_AsVal_int(obj3, &val4);
33972 if (!SWIG_IsOK(ecode4)) {
33973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33974 }
33975 arg4 = static_cast< wxDragResult >(val4);
33976 {
33977 PyThreadState* __tstate = wxPyBeginAllowThreads();
33978 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33979 wxPyEndAllowThreads(__tstate);
33980 if (PyErr_Occurred()) SWIG_fail;
33981 }
33982 resultobj = SWIG_From_int(static_cast< int >(result));
33983 return resultobj;
33984 fail:
33985 return NULL;
33986 }
33987
33988
33989 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33990 PyObject *obj;
33991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33992 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33993 return SWIG_Py_Void();
33994 }
33995
33996 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33997 return SWIG_Python_InitShadowInstance(args);
33998 }
33999
34000 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34001 PyObject *resultobj = 0;
34002 wxClipboard *result = 0 ;
34003
34004 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34005 {
34006 PyThreadState* __tstate = wxPyBeginAllowThreads();
34007 result = (wxClipboard *)new wxClipboard();
34008 wxPyEndAllowThreads(__tstate);
34009 if (PyErr_Occurred()) SWIG_fail;
34010 }
34011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34019 PyObject *resultobj = 0;
34020 wxClipboard *arg1 = (wxClipboard *) 0 ;
34021 void *argp1 = 0 ;
34022 int res1 = 0 ;
34023 PyObject *swig_obj[1] ;
34024
34025 if (!args) SWIG_fail;
34026 swig_obj[0] = args;
34027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34028 if (!SWIG_IsOK(res1)) {
34029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34030 }
34031 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34032 {
34033 PyThreadState* __tstate = wxPyBeginAllowThreads();
34034 delete arg1;
34035
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 resultobj = SWIG_Py_Void();
34040 return resultobj;
34041 fail:
34042 return NULL;
34043 }
34044
34045
34046 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34047 PyObject *resultobj = 0;
34048 wxClipboard *arg1 = (wxClipboard *) 0 ;
34049 bool result;
34050 void *argp1 = 0 ;
34051 int res1 = 0 ;
34052 PyObject *swig_obj[1] ;
34053
34054 if (!args) SWIG_fail;
34055 swig_obj[0] = args;
34056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34057 if (!SWIG_IsOK(res1)) {
34058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34059 }
34060 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34061 {
34062 PyThreadState* __tstate = wxPyBeginAllowThreads();
34063 result = (bool)(arg1)->Open();
34064 wxPyEndAllowThreads(__tstate);
34065 if (PyErr_Occurred()) SWIG_fail;
34066 }
34067 {
34068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34069 }
34070 return resultobj;
34071 fail:
34072 return NULL;
34073 }
34074
34075
34076 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34077 PyObject *resultobj = 0;
34078 wxClipboard *arg1 = (wxClipboard *) 0 ;
34079 void *argp1 = 0 ;
34080 int res1 = 0 ;
34081 PyObject *swig_obj[1] ;
34082
34083 if (!args) SWIG_fail;
34084 swig_obj[0] = args;
34085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34088 }
34089 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34090 {
34091 PyThreadState* __tstate = wxPyBeginAllowThreads();
34092 (arg1)->Close();
34093 wxPyEndAllowThreads(__tstate);
34094 if (PyErr_Occurred()) SWIG_fail;
34095 }
34096 resultobj = SWIG_Py_Void();
34097 return resultobj;
34098 fail:
34099 return NULL;
34100 }
34101
34102
34103 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34104 PyObject *resultobj = 0;
34105 wxClipboard *arg1 = (wxClipboard *) 0 ;
34106 bool result;
34107 void *argp1 = 0 ;
34108 int res1 = 0 ;
34109 PyObject *swig_obj[1] ;
34110
34111 if (!args) SWIG_fail;
34112 swig_obj[0] = args;
34113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34114 if (!SWIG_IsOK(res1)) {
34115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34116 }
34117 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34118 {
34119 PyThreadState* __tstate = wxPyBeginAllowThreads();
34120 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34121 wxPyEndAllowThreads(__tstate);
34122 if (PyErr_Occurred()) SWIG_fail;
34123 }
34124 {
34125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34126 }
34127 return resultobj;
34128 fail:
34129 return NULL;
34130 }
34131
34132
34133 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34134 PyObject *resultobj = 0;
34135 wxClipboard *arg1 = (wxClipboard *) 0 ;
34136 wxDataObject *arg2 = (wxDataObject *) 0 ;
34137 bool result;
34138 void *argp1 = 0 ;
34139 int res1 = 0 ;
34140 int res2 = 0 ;
34141 PyObject * obj0 = 0 ;
34142 PyObject * obj1 = 0 ;
34143 char * kwnames[] = {
34144 (char *) "self",(char *) "data", NULL
34145 };
34146
34147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34149 if (!SWIG_IsOK(res1)) {
34150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34151 }
34152 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34153 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34154 if (!SWIG_IsOK(res2)) {
34155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34156 }
34157 {
34158 PyThreadState* __tstate = wxPyBeginAllowThreads();
34159 result = (bool)(arg1)->AddData(arg2);
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 {
34164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34165 }
34166 return resultobj;
34167 fail:
34168 return NULL;
34169 }
34170
34171
34172 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34173 PyObject *resultobj = 0;
34174 wxClipboard *arg1 = (wxClipboard *) 0 ;
34175 wxDataObject *arg2 = (wxDataObject *) 0 ;
34176 bool result;
34177 void *argp1 = 0 ;
34178 int res1 = 0 ;
34179 int res2 = 0 ;
34180 PyObject * obj0 = 0 ;
34181 PyObject * obj1 = 0 ;
34182 char * kwnames[] = {
34183 (char *) "self",(char *) "data", NULL
34184 };
34185
34186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34188 if (!SWIG_IsOK(res1)) {
34189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34190 }
34191 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34192 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34193 if (!SWIG_IsOK(res2)) {
34194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34195 }
34196 {
34197 PyThreadState* __tstate = wxPyBeginAllowThreads();
34198 result = (bool)(arg1)->SetData(arg2);
34199 wxPyEndAllowThreads(__tstate);
34200 if (PyErr_Occurred()) SWIG_fail;
34201 }
34202 {
34203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34204 }
34205 return resultobj;
34206 fail:
34207 return NULL;
34208 }
34209
34210
34211 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34212 PyObject *resultobj = 0;
34213 wxClipboard *arg1 = (wxClipboard *) 0 ;
34214 wxDataFormat *arg2 = 0 ;
34215 bool result;
34216 void *argp1 = 0 ;
34217 int res1 = 0 ;
34218 void *argp2 = 0 ;
34219 int res2 = 0 ;
34220 PyObject * obj0 = 0 ;
34221 PyObject * obj1 = 0 ;
34222 char * kwnames[] = {
34223 (char *) "self",(char *) "format", NULL
34224 };
34225
34226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34228 if (!SWIG_IsOK(res1)) {
34229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34230 }
34231 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34232 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34233 if (!SWIG_IsOK(res2)) {
34234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34235 }
34236 if (!argp2) {
34237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34238 }
34239 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 {
34247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34248 }
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34256 PyObject *resultobj = 0;
34257 wxClipboard *arg1 = (wxClipboard *) 0 ;
34258 wxDataObject *arg2 = 0 ;
34259 bool result;
34260 void *argp1 = 0 ;
34261 int res1 = 0 ;
34262 void *argp2 = 0 ;
34263 int res2 = 0 ;
34264 PyObject * obj0 = 0 ;
34265 PyObject * obj1 = 0 ;
34266 char * kwnames[] = {
34267 (char *) "self",(char *) "data", NULL
34268 };
34269
34270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34272 if (!SWIG_IsOK(res1)) {
34273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34274 }
34275 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34276 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34277 if (!SWIG_IsOK(res2)) {
34278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34279 }
34280 if (!argp2) {
34281 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34282 }
34283 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34284 {
34285 PyThreadState* __tstate = wxPyBeginAllowThreads();
34286 result = (bool)(arg1)->GetData(*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_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34300 PyObject *resultobj = 0;
34301 wxClipboard *arg1 = (wxClipboard *) 0 ;
34302 void *argp1 = 0 ;
34303 int res1 = 0 ;
34304 PyObject *swig_obj[1] ;
34305
34306 if (!args) SWIG_fail;
34307 swig_obj[0] = args;
34308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34309 if (!SWIG_IsOK(res1)) {
34310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34311 }
34312 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34313 {
34314 PyThreadState* __tstate = wxPyBeginAllowThreads();
34315 (arg1)->Clear();
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 resultobj = SWIG_Py_Void();
34320 return resultobj;
34321 fail:
34322 return NULL;
34323 }
34324
34325
34326 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34327 PyObject *resultobj = 0;
34328 wxClipboard *arg1 = (wxClipboard *) 0 ;
34329 bool result;
34330 void *argp1 = 0 ;
34331 int res1 = 0 ;
34332 PyObject *swig_obj[1] ;
34333
34334 if (!args) SWIG_fail;
34335 swig_obj[0] = args;
34336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34337 if (!SWIG_IsOK(res1)) {
34338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34339 }
34340 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34341 {
34342 PyThreadState* __tstate = wxPyBeginAllowThreads();
34343 result = (bool)(arg1)->Flush();
34344 wxPyEndAllowThreads(__tstate);
34345 if (PyErr_Occurred()) SWIG_fail;
34346 }
34347 {
34348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34349 }
34350 return resultobj;
34351 fail:
34352 return NULL;
34353 }
34354
34355
34356 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34357 PyObject *resultobj = 0;
34358 wxClipboard *arg1 = (wxClipboard *) 0 ;
34359 bool arg2 = (bool) true ;
34360 void *argp1 = 0 ;
34361 int res1 = 0 ;
34362 bool val2 ;
34363 int ecode2 = 0 ;
34364 PyObject * obj0 = 0 ;
34365 PyObject * obj1 = 0 ;
34366 char * kwnames[] = {
34367 (char *) "self",(char *) "primary", NULL
34368 };
34369
34370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34372 if (!SWIG_IsOK(res1)) {
34373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34374 }
34375 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34376 if (obj1) {
34377 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34378 if (!SWIG_IsOK(ecode2)) {
34379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34380 }
34381 arg2 = static_cast< bool >(val2);
34382 }
34383 {
34384 PyThreadState* __tstate = wxPyBeginAllowThreads();
34385 (arg1)->UsePrimarySelection(arg2);
34386 wxPyEndAllowThreads(__tstate);
34387 if (PyErr_Occurred()) SWIG_fail;
34388 }
34389 resultobj = SWIG_Py_Void();
34390 return resultobj;
34391 fail:
34392 return NULL;
34393 }
34394
34395
34396 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34397 PyObject *resultobj = 0;
34398 wxClipboard *result = 0 ;
34399
34400 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = (wxClipboard *)wxClipboard::Get();
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34415 PyObject *obj;
34416 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34417 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34418 return SWIG_Py_Void();
34419 }
34420
34421 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34422 return SWIG_Python_InitShadowInstance(args);
34423 }
34424
34425 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34426 PyObject *resultobj = 0;
34427 wxClipboard *arg1 = (wxClipboard *) NULL ;
34428 wxClipboardLocker *result = 0 ;
34429 void *argp1 = 0 ;
34430 int res1 = 0 ;
34431 PyObject * obj0 = 0 ;
34432 char * kwnames[] = {
34433 (char *) "clipboard", NULL
34434 };
34435
34436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34437 if (obj0) {
34438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34439 if (!SWIG_IsOK(res1)) {
34440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34441 }
34442 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34443 }
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34447 wxPyEndAllowThreads(__tstate);
34448 if (PyErr_Occurred()) SWIG_fail;
34449 }
34450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34451 return resultobj;
34452 fail:
34453 return NULL;
34454 }
34455
34456
34457 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 PyObject *resultobj = 0;
34459 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34460 void *argp1 = 0 ;
34461 int res1 = 0 ;
34462 PyObject *swig_obj[1] ;
34463
34464 if (!args) SWIG_fail;
34465 swig_obj[0] = args;
34466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34467 if (!SWIG_IsOK(res1)) {
34468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34469 }
34470 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34471 {
34472 PyThreadState* __tstate = wxPyBeginAllowThreads();
34473 delete arg1;
34474
34475 wxPyEndAllowThreads(__tstate);
34476 if (PyErr_Occurred()) SWIG_fail;
34477 }
34478 resultobj = SWIG_Py_Void();
34479 return resultobj;
34480 fail:
34481 return NULL;
34482 }
34483
34484
34485 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34486 PyObject *resultobj = 0;
34487 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34488 bool result;
34489 void *argp1 = 0 ;
34490 int res1 = 0 ;
34491 PyObject *swig_obj[1] ;
34492
34493 if (!args) SWIG_fail;
34494 swig_obj[0] = args;
34495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34496 if (!SWIG_IsOK(res1)) {
34497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34498 }
34499 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34500 {
34501 PyThreadState* __tstate = wxPyBeginAllowThreads();
34502 result = (bool)wxClipboardLocker___nonzero__(arg1);
34503 wxPyEndAllowThreads(__tstate);
34504 if (PyErr_Occurred()) SWIG_fail;
34505 }
34506 {
34507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34508 }
34509 return resultobj;
34510 fail:
34511 return NULL;
34512 }
34513
34514
34515 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34516 PyObject *obj;
34517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34518 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34519 return SWIG_Py_Void();
34520 }
34521
34522 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34523 return SWIG_Python_InitShadowInstance(args);
34524 }
34525
34526 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34527 PyObject *resultobj = 0;
34528 int arg1 = (int) 0 ;
34529 int arg2 = (int) 0 ;
34530 int arg3 = (int) 0 ;
34531 int arg4 = (int) 0 ;
34532 wxVideoMode *result = 0 ;
34533 int val1 ;
34534 int ecode1 = 0 ;
34535 int val2 ;
34536 int ecode2 = 0 ;
34537 int val3 ;
34538 int ecode3 = 0 ;
34539 int val4 ;
34540 int ecode4 = 0 ;
34541 PyObject * obj0 = 0 ;
34542 PyObject * obj1 = 0 ;
34543 PyObject * obj2 = 0 ;
34544 PyObject * obj3 = 0 ;
34545 char * kwnames[] = {
34546 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34547 };
34548
34549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34550 if (obj0) {
34551 ecode1 = SWIG_AsVal_int(obj0, &val1);
34552 if (!SWIG_IsOK(ecode1)) {
34553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34554 }
34555 arg1 = static_cast< int >(val1);
34556 }
34557 if (obj1) {
34558 ecode2 = SWIG_AsVal_int(obj1, &val2);
34559 if (!SWIG_IsOK(ecode2)) {
34560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34561 }
34562 arg2 = static_cast< int >(val2);
34563 }
34564 if (obj2) {
34565 ecode3 = SWIG_AsVal_int(obj2, &val3);
34566 if (!SWIG_IsOK(ecode3)) {
34567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34568 }
34569 arg3 = static_cast< int >(val3);
34570 }
34571 if (obj3) {
34572 ecode4 = SWIG_AsVal_int(obj3, &val4);
34573 if (!SWIG_IsOK(ecode4)) {
34574 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34575 }
34576 arg4 = static_cast< int >(val4);
34577 }
34578 {
34579 PyThreadState* __tstate = wxPyBeginAllowThreads();
34580 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34581 wxPyEndAllowThreads(__tstate);
34582 if (PyErr_Occurred()) SWIG_fail;
34583 }
34584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34585 return resultobj;
34586 fail:
34587 return NULL;
34588 }
34589
34590
34591 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34592 PyObject *resultobj = 0;
34593 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34594 void *argp1 = 0 ;
34595 int res1 = 0 ;
34596 PyObject *swig_obj[1] ;
34597
34598 if (!args) SWIG_fail;
34599 swig_obj[0] = args;
34600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34601 if (!SWIG_IsOK(res1)) {
34602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34603 }
34604 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34605 {
34606 PyThreadState* __tstate = wxPyBeginAllowThreads();
34607 delete arg1;
34608
34609 wxPyEndAllowThreads(__tstate);
34610 if (PyErr_Occurred()) SWIG_fail;
34611 }
34612 resultobj = SWIG_Py_Void();
34613 return resultobj;
34614 fail:
34615 return NULL;
34616 }
34617
34618
34619 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34620 PyObject *resultobj = 0;
34621 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34622 wxVideoMode *arg2 = 0 ;
34623 bool result;
34624 void *argp1 = 0 ;
34625 int res1 = 0 ;
34626 void *argp2 = 0 ;
34627 int res2 = 0 ;
34628 PyObject * obj0 = 0 ;
34629 PyObject * obj1 = 0 ;
34630 char * kwnames[] = {
34631 (char *) "self",(char *) "other", NULL
34632 };
34633
34634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34636 if (!SWIG_IsOK(res1)) {
34637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34638 }
34639 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34640 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34641 if (!SWIG_IsOK(res2)) {
34642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34643 }
34644 if (!argp2) {
34645 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34646 }
34647 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34648 {
34649 PyThreadState* __tstate = wxPyBeginAllowThreads();
34650 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34651 wxPyEndAllowThreads(__tstate);
34652 if (PyErr_Occurred()) SWIG_fail;
34653 }
34654 {
34655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34656 }
34657 return resultobj;
34658 fail:
34659 return NULL;
34660 }
34661
34662
34663 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34664 PyObject *resultobj = 0;
34665 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34666 int result;
34667 void *argp1 = 0 ;
34668 int res1 = 0 ;
34669 PyObject *swig_obj[1] ;
34670
34671 if (!args) SWIG_fail;
34672 swig_obj[0] = args;
34673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34674 if (!SWIG_IsOK(res1)) {
34675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34676 }
34677 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34678 {
34679 PyThreadState* __tstate = wxPyBeginAllowThreads();
34680 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34681 wxPyEndAllowThreads(__tstate);
34682 if (PyErr_Occurred()) SWIG_fail;
34683 }
34684 resultobj = SWIG_From_int(static_cast< int >(result));
34685 return resultobj;
34686 fail:
34687 return NULL;
34688 }
34689
34690
34691 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34692 PyObject *resultobj = 0;
34693 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34694 int result;
34695 void *argp1 = 0 ;
34696 int res1 = 0 ;
34697 PyObject *swig_obj[1] ;
34698
34699 if (!args) SWIG_fail;
34700 swig_obj[0] = args;
34701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34702 if (!SWIG_IsOK(res1)) {
34703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34704 }
34705 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34706 {
34707 PyThreadState* __tstate = wxPyBeginAllowThreads();
34708 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34709 wxPyEndAllowThreads(__tstate);
34710 if (PyErr_Occurred()) SWIG_fail;
34711 }
34712 resultobj = SWIG_From_int(static_cast< int >(result));
34713 return resultobj;
34714 fail:
34715 return NULL;
34716 }
34717
34718
34719 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34720 PyObject *resultobj = 0;
34721 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34722 int result;
34723 void *argp1 = 0 ;
34724 int res1 = 0 ;
34725 PyObject *swig_obj[1] ;
34726
34727 if (!args) SWIG_fail;
34728 swig_obj[0] = args;
34729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34730 if (!SWIG_IsOK(res1)) {
34731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34732 }
34733 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34737 wxPyEndAllowThreads(__tstate);
34738 if (PyErr_Occurred()) SWIG_fail;
34739 }
34740 resultobj = SWIG_From_int(static_cast< int >(result));
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34748 PyObject *resultobj = 0;
34749 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34750 bool result;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 PyObject *swig_obj[1] ;
34754
34755 if (!args) SWIG_fail;
34756 swig_obj[0] = args;
34757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34758 if (!SWIG_IsOK(res1)) {
34759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34760 }
34761 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 {
34769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34770 }
34771 return resultobj;
34772 fail:
34773 return NULL;
34774 }
34775
34776
34777 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34778 PyObject *resultobj = 0;
34779 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34780 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34781 bool result;
34782 void *argp1 = 0 ;
34783 int res1 = 0 ;
34784 void *argp2 = 0 ;
34785 int res2 = 0 ;
34786 PyObject * obj0 = 0 ;
34787 PyObject * obj1 = 0 ;
34788 char * kwnames[] = {
34789 (char *) "self",(char *) "other", NULL
34790 };
34791
34792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34794 if (!SWIG_IsOK(res1)) {
34795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34796 }
34797 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34799 if (!SWIG_IsOK(res2)) {
34800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34801 }
34802 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34803 {
34804 PyThreadState* __tstate = wxPyBeginAllowThreads();
34805 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34806 wxPyEndAllowThreads(__tstate);
34807 if (PyErr_Occurred()) SWIG_fail;
34808 }
34809 {
34810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34811 }
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34819 PyObject *resultobj = 0;
34820 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34821 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34822 bool result;
34823 void *argp1 = 0 ;
34824 int res1 = 0 ;
34825 void *argp2 = 0 ;
34826 int res2 = 0 ;
34827 PyObject * obj0 = 0 ;
34828 PyObject * obj1 = 0 ;
34829 char * kwnames[] = {
34830 (char *) "self",(char *) "other", NULL
34831 };
34832
34833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34835 if (!SWIG_IsOK(res1)) {
34836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34837 }
34838 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34840 if (!SWIG_IsOK(res2)) {
34841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34842 }
34843 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34844 {
34845 PyThreadState* __tstate = wxPyBeginAllowThreads();
34846 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34847 wxPyEndAllowThreads(__tstate);
34848 if (PyErr_Occurred()) SWIG_fail;
34849 }
34850 {
34851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34852 }
34853 return resultobj;
34854 fail:
34855 return NULL;
34856 }
34857
34858
34859 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34860 PyObject *resultobj = 0;
34861 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34862 int arg2 ;
34863 void *argp1 = 0 ;
34864 int res1 = 0 ;
34865 int val2 ;
34866 int ecode2 = 0 ;
34867 PyObject *swig_obj[2] ;
34868
34869 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34871 if (!SWIG_IsOK(res1)) {
34872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34873 }
34874 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34875 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34876 if (!SWIG_IsOK(ecode2)) {
34877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34878 }
34879 arg2 = static_cast< int >(val2);
34880 if (arg1) (arg1)->w = arg2;
34881
34882 resultobj = SWIG_Py_Void();
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34890 PyObject *resultobj = 0;
34891 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34892 int result;
34893 void *argp1 = 0 ;
34894 int res1 = 0 ;
34895 PyObject *swig_obj[1] ;
34896
34897 if (!args) SWIG_fail;
34898 swig_obj[0] = args;
34899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34900 if (!SWIG_IsOK(res1)) {
34901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34902 }
34903 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34904 result = (int) ((arg1)->w);
34905 resultobj = SWIG_From_int(static_cast< int >(result));
34906 return resultobj;
34907 fail:
34908 return NULL;
34909 }
34910
34911
34912 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34913 PyObject *resultobj = 0;
34914 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34915 int arg2 ;
34916 void *argp1 = 0 ;
34917 int res1 = 0 ;
34918 int val2 ;
34919 int ecode2 = 0 ;
34920 PyObject *swig_obj[2] ;
34921
34922 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34924 if (!SWIG_IsOK(res1)) {
34925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34926 }
34927 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34928 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34929 if (!SWIG_IsOK(ecode2)) {
34930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34931 }
34932 arg2 = static_cast< int >(val2);
34933 if (arg1) (arg1)->h = arg2;
34934
34935 resultobj = SWIG_Py_Void();
34936 return resultobj;
34937 fail:
34938 return NULL;
34939 }
34940
34941
34942 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34943 PyObject *resultobj = 0;
34944 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34945 int result;
34946 void *argp1 = 0 ;
34947 int res1 = 0 ;
34948 PyObject *swig_obj[1] ;
34949
34950 if (!args) SWIG_fail;
34951 swig_obj[0] = args;
34952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34953 if (!SWIG_IsOK(res1)) {
34954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34955 }
34956 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34957 result = (int) ((arg1)->h);
34958 resultobj = SWIG_From_int(static_cast< int >(result));
34959 return resultobj;
34960 fail:
34961 return NULL;
34962 }
34963
34964
34965 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34966 PyObject *resultobj = 0;
34967 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34968 int arg2 ;
34969 void *argp1 = 0 ;
34970 int res1 = 0 ;
34971 int val2 ;
34972 int ecode2 = 0 ;
34973 PyObject *swig_obj[2] ;
34974
34975 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34977 if (!SWIG_IsOK(res1)) {
34978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34979 }
34980 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34981 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34982 if (!SWIG_IsOK(ecode2)) {
34983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34984 }
34985 arg2 = static_cast< int >(val2);
34986 if (arg1) (arg1)->bpp = arg2;
34987
34988 resultobj = SWIG_Py_Void();
34989 return resultobj;
34990 fail:
34991 return NULL;
34992 }
34993
34994
34995 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34996 PyObject *resultobj = 0;
34997 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34998 int result;
34999 void *argp1 = 0 ;
35000 int res1 = 0 ;
35001 PyObject *swig_obj[1] ;
35002
35003 if (!args) SWIG_fail;
35004 swig_obj[0] = args;
35005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35006 if (!SWIG_IsOK(res1)) {
35007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35008 }
35009 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35010 result = (int) ((arg1)->bpp);
35011 resultobj = SWIG_From_int(static_cast< int >(result));
35012 return resultobj;
35013 fail:
35014 return NULL;
35015 }
35016
35017
35018 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35019 PyObject *resultobj = 0;
35020 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35021 int arg2 ;
35022 void *argp1 = 0 ;
35023 int res1 = 0 ;
35024 int val2 ;
35025 int ecode2 = 0 ;
35026 PyObject *swig_obj[2] ;
35027
35028 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35030 if (!SWIG_IsOK(res1)) {
35031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35032 }
35033 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35034 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35035 if (!SWIG_IsOK(ecode2)) {
35036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35037 }
35038 arg2 = static_cast< int >(val2);
35039 if (arg1) (arg1)->refresh = arg2;
35040
35041 resultobj = SWIG_Py_Void();
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35049 PyObject *resultobj = 0;
35050 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35051 int result;
35052 void *argp1 = 0 ;
35053 int res1 = 0 ;
35054 PyObject *swig_obj[1] ;
35055
35056 if (!args) SWIG_fail;
35057 swig_obj[0] = args;
35058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35059 if (!SWIG_IsOK(res1)) {
35060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35061 }
35062 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35063 result = (int) ((arg1)->refresh);
35064 resultobj = SWIG_From_int(static_cast< int >(result));
35065 return resultobj;
35066 fail:
35067 return NULL;
35068 }
35069
35070
35071 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35072 PyObject *obj;
35073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35074 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35075 return SWIG_Py_Void();
35076 }
35077
35078 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35079 return SWIG_Python_InitShadowInstance(args);
35080 }
35081
35082 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35083 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35084 return 1;
35085 }
35086
35087
35088 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35089 PyObject *pyobj = 0;
35090
35091 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35092 return pyobj;
35093 }
35094
35095
35096 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35097 PyObject *resultobj = 0;
35098 size_t arg1 = (size_t) 0 ;
35099 wxDisplay *result = 0 ;
35100 size_t val1 ;
35101 int ecode1 = 0 ;
35102 PyObject * obj0 = 0 ;
35103 char * kwnames[] = {
35104 (char *) "index", NULL
35105 };
35106
35107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35108 if (obj0) {
35109 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35110 if (!SWIG_IsOK(ecode1)) {
35111 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35112 }
35113 arg1 = static_cast< size_t >(val1);
35114 }
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = (wxDisplay *)new wxDisplay(arg1);
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35129 PyObject *resultobj = 0;
35130 wxDisplay *arg1 = (wxDisplay *) 0 ;
35131 void *argp1 = 0 ;
35132 int res1 = 0 ;
35133 PyObject *swig_obj[1] ;
35134
35135 if (!args) SWIG_fail;
35136 swig_obj[0] = args;
35137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35138 if (!SWIG_IsOK(res1)) {
35139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35140 }
35141 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35142 {
35143 PyThreadState* __tstate = wxPyBeginAllowThreads();
35144 delete arg1;
35145
35146 wxPyEndAllowThreads(__tstate);
35147 if (PyErr_Occurred()) SWIG_fail;
35148 }
35149 resultobj = SWIG_Py_Void();
35150 return resultobj;
35151 fail:
35152 return NULL;
35153 }
35154
35155
35156 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35157 PyObject *resultobj = 0;
35158 size_t result;
35159
35160 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35161 {
35162 PyThreadState* __tstate = wxPyBeginAllowThreads();
35163 result = (size_t)wxDisplay::GetCount();
35164 wxPyEndAllowThreads(__tstate);
35165 if (PyErr_Occurred()) SWIG_fail;
35166 }
35167 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35168 return resultobj;
35169 fail:
35170 return NULL;
35171 }
35172
35173
35174 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35175 PyObject *resultobj = 0;
35176 wxPoint *arg1 = 0 ;
35177 int result;
35178 wxPoint temp1 ;
35179 PyObject * obj0 = 0 ;
35180 char * kwnames[] = {
35181 (char *) "pt", NULL
35182 };
35183
35184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35185 {
35186 arg1 = &temp1;
35187 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35188 }
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 resultobj = SWIG_From_int(static_cast< int >(result));
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35203 PyObject *resultobj = 0;
35204 wxWindow *arg1 = (wxWindow *) 0 ;
35205 int result;
35206 void *argp1 = 0 ;
35207 int res1 = 0 ;
35208 PyObject * obj0 = 0 ;
35209 char * kwnames[] = {
35210 (char *) "window", NULL
35211 };
35212
35213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35215 if (!SWIG_IsOK(res1)) {
35216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35217 }
35218 arg1 = reinterpret_cast< wxWindow * >(argp1);
35219 {
35220 PyThreadState* __tstate = wxPyBeginAllowThreads();
35221 result = (int)wxDisplay::GetFromWindow(arg1);
35222 wxPyEndAllowThreads(__tstate);
35223 if (PyErr_Occurred()) SWIG_fail;
35224 }
35225 resultobj = SWIG_From_int(static_cast< int >(result));
35226 return resultobj;
35227 fail:
35228 return NULL;
35229 }
35230
35231
35232 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35233 PyObject *resultobj = 0;
35234 wxDisplay *arg1 = (wxDisplay *) 0 ;
35235 bool result;
35236 void *argp1 = 0 ;
35237 int res1 = 0 ;
35238 PyObject *swig_obj[1] ;
35239
35240 if (!args) SWIG_fail;
35241 swig_obj[0] = args;
35242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35243 if (!SWIG_IsOK(res1)) {
35244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35245 }
35246 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35247 {
35248 PyThreadState* __tstate = wxPyBeginAllowThreads();
35249 result = (bool)((wxDisplay const *)arg1)->IsOk();
35250 wxPyEndAllowThreads(__tstate);
35251 if (PyErr_Occurred()) SWIG_fail;
35252 }
35253 {
35254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35255 }
35256 return resultobj;
35257 fail:
35258 return NULL;
35259 }
35260
35261
35262 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35263 PyObject *resultobj = 0;
35264 wxDisplay *arg1 = (wxDisplay *) 0 ;
35265 wxRect result;
35266 void *argp1 = 0 ;
35267 int res1 = 0 ;
35268 PyObject *swig_obj[1] ;
35269
35270 if (!args) SWIG_fail;
35271 swig_obj[0] = args;
35272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35273 if (!SWIG_IsOK(res1)) {
35274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35275 }
35276 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35277 {
35278 PyThreadState* __tstate = wxPyBeginAllowThreads();
35279 result = ((wxDisplay const *)arg1)->GetGeometry();
35280 wxPyEndAllowThreads(__tstate);
35281 if (PyErr_Occurred()) SWIG_fail;
35282 }
35283 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35284 return resultobj;
35285 fail:
35286 return NULL;
35287 }
35288
35289
35290 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35291 PyObject *resultobj = 0;
35292 wxDisplay *arg1 = (wxDisplay *) 0 ;
35293 wxRect result;
35294 void *argp1 = 0 ;
35295 int res1 = 0 ;
35296 PyObject *swig_obj[1] ;
35297
35298 if (!args) SWIG_fail;
35299 swig_obj[0] = args;
35300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35301 if (!SWIG_IsOK(res1)) {
35302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35303 }
35304 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35305 {
35306 PyThreadState* __tstate = wxPyBeginAllowThreads();
35307 result = ((wxDisplay const *)arg1)->GetClientArea();
35308 wxPyEndAllowThreads(__tstate);
35309 if (PyErr_Occurred()) SWIG_fail;
35310 }
35311 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35312 return resultobj;
35313 fail:
35314 return NULL;
35315 }
35316
35317
35318 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35319 PyObject *resultobj = 0;
35320 wxDisplay *arg1 = (wxDisplay *) 0 ;
35321 wxString result;
35322 void *argp1 = 0 ;
35323 int res1 = 0 ;
35324 PyObject *swig_obj[1] ;
35325
35326 if (!args) SWIG_fail;
35327 swig_obj[0] = args;
35328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35329 if (!SWIG_IsOK(res1)) {
35330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35331 }
35332 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35333 {
35334 PyThreadState* __tstate = wxPyBeginAllowThreads();
35335 result = ((wxDisplay const *)arg1)->GetName();
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 {
35340 #if wxUSE_UNICODE
35341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35342 #else
35343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35344 #endif
35345 }
35346 return resultobj;
35347 fail:
35348 return NULL;
35349 }
35350
35351
35352 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35353 PyObject *resultobj = 0;
35354 wxDisplay *arg1 = (wxDisplay *) 0 ;
35355 bool result;
35356 void *argp1 = 0 ;
35357 int res1 = 0 ;
35358 PyObject *swig_obj[1] ;
35359
35360 if (!args) SWIG_fail;
35361 swig_obj[0] = args;
35362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35363 if (!SWIG_IsOK(res1)) {
35364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35365 }
35366 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35367 {
35368 PyThreadState* __tstate = wxPyBeginAllowThreads();
35369 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 {
35374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35375 }
35376 return resultobj;
35377 fail:
35378 return NULL;
35379 }
35380
35381
35382 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35383 PyObject *resultobj = 0;
35384 wxDisplay *arg1 = (wxDisplay *) 0 ;
35385 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35386 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35387 PyObject *result = 0 ;
35388 void *argp1 = 0 ;
35389 int res1 = 0 ;
35390 void *argp2 = 0 ;
35391 int res2 = 0 ;
35392 PyObject * obj0 = 0 ;
35393 PyObject * obj1 = 0 ;
35394 char * kwnames[] = {
35395 (char *) "self",(char *) "mode", NULL
35396 };
35397
35398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35400 if (!SWIG_IsOK(res1)) {
35401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35402 }
35403 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35404 if (obj1) {
35405 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35406 if (!SWIG_IsOK(res2)) {
35407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35408 }
35409 if (!argp2) {
35410 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35411 }
35412 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35413 }
35414 {
35415 PyThreadState* __tstate = wxPyBeginAllowThreads();
35416 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35417 wxPyEndAllowThreads(__tstate);
35418 if (PyErr_Occurred()) SWIG_fail;
35419 }
35420 resultobj = result;
35421 return resultobj;
35422 fail:
35423 return NULL;
35424 }
35425
35426
35427 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35428 PyObject *resultobj = 0;
35429 wxDisplay *arg1 = (wxDisplay *) 0 ;
35430 wxVideoMode result;
35431 void *argp1 = 0 ;
35432 int res1 = 0 ;
35433 PyObject *swig_obj[1] ;
35434
35435 if (!args) SWIG_fail;
35436 swig_obj[0] = args;
35437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35438 if (!SWIG_IsOK(res1)) {
35439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35440 }
35441 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35442 {
35443 PyThreadState* __tstate = wxPyBeginAllowThreads();
35444 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35445 wxPyEndAllowThreads(__tstate);
35446 if (PyErr_Occurred()) SWIG_fail;
35447 }
35448 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35449 return resultobj;
35450 fail:
35451 return NULL;
35452 }
35453
35454
35455 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35456 PyObject *resultobj = 0;
35457 wxDisplay *arg1 = (wxDisplay *) 0 ;
35458 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35459 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35460 bool result;
35461 void *argp1 = 0 ;
35462 int res1 = 0 ;
35463 void *argp2 = 0 ;
35464 int res2 = 0 ;
35465 PyObject * obj0 = 0 ;
35466 PyObject * obj1 = 0 ;
35467 char * kwnames[] = {
35468 (char *) "self",(char *) "mode", NULL
35469 };
35470
35471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35473 if (!SWIG_IsOK(res1)) {
35474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35475 }
35476 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35477 if (obj1) {
35478 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35479 if (!SWIG_IsOK(res2)) {
35480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35481 }
35482 if (!argp2) {
35483 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35484 }
35485 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35486 }
35487 {
35488 PyThreadState* __tstate = wxPyBeginAllowThreads();
35489 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35490 wxPyEndAllowThreads(__tstate);
35491 if (PyErr_Occurred()) SWIG_fail;
35492 }
35493 {
35494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35495 }
35496 return resultobj;
35497 fail:
35498 return NULL;
35499 }
35500
35501
35502 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35503 PyObject *resultobj = 0;
35504 wxDisplay *arg1 = (wxDisplay *) 0 ;
35505 void *argp1 = 0 ;
35506 int res1 = 0 ;
35507 PyObject *swig_obj[1] ;
35508
35509 if (!args) SWIG_fail;
35510 swig_obj[0] = args;
35511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35512 if (!SWIG_IsOK(res1)) {
35513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35514 }
35515 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35516 {
35517 PyThreadState* __tstate = wxPyBeginAllowThreads();
35518 wxDisplay_ResetMode(arg1);
35519 wxPyEndAllowThreads(__tstate);
35520 if (PyErr_Occurred()) SWIG_fail;
35521 }
35522 resultobj = SWIG_Py_Void();
35523 return resultobj;
35524 fail:
35525 return NULL;
35526 }
35527
35528
35529 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35530 PyObject *obj;
35531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35532 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35533 return SWIG_Py_Void();
35534 }
35535
35536 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35537 return SWIG_Python_InitShadowInstance(args);
35538 }
35539
35540 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35541 PyObject *resultobj = 0;
35542 wxStandardPaths *result = 0 ;
35543
35544 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 result = (wxStandardPaths *)wxStandardPaths_Get();
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35552 return resultobj;
35553 fail:
35554 return NULL;
35555 }
35556
35557
35558 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35559 PyObject *resultobj = 0;
35560 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35561 wxString result;
35562 void *argp1 = 0 ;
35563 int res1 = 0 ;
35564 PyObject *swig_obj[1] ;
35565
35566 if (!args) SWIG_fail;
35567 swig_obj[0] = args;
35568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35569 if (!SWIG_IsOK(res1)) {
35570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35571 }
35572 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 {
35580 #if wxUSE_UNICODE
35581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35582 #else
35583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35584 #endif
35585 }
35586 return resultobj;
35587 fail:
35588 return NULL;
35589 }
35590
35591
35592 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35593 PyObject *resultobj = 0;
35594 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35595 wxString result;
35596 void *argp1 = 0 ;
35597 int res1 = 0 ;
35598 PyObject *swig_obj[1] ;
35599
35600 if (!args) SWIG_fail;
35601 swig_obj[0] = args;
35602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35603 if (!SWIG_IsOK(res1)) {
35604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35605 }
35606 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35607 {
35608 PyThreadState* __tstate = wxPyBeginAllowThreads();
35609 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35610 wxPyEndAllowThreads(__tstate);
35611 if (PyErr_Occurred()) SWIG_fail;
35612 }
35613 {
35614 #if wxUSE_UNICODE
35615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35616 #else
35617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35618 #endif
35619 }
35620 return resultobj;
35621 fail:
35622 return NULL;
35623 }
35624
35625
35626 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35627 PyObject *resultobj = 0;
35628 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35629 wxString result;
35630 void *argp1 = 0 ;
35631 int res1 = 0 ;
35632 PyObject *swig_obj[1] ;
35633
35634 if (!args) SWIG_fail;
35635 swig_obj[0] = args;
35636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35637 if (!SWIG_IsOK(res1)) {
35638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35639 }
35640 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35641 {
35642 PyThreadState* __tstate = wxPyBeginAllowThreads();
35643 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 {
35648 #if wxUSE_UNICODE
35649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35650 #else
35651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35652 #endif
35653 }
35654 return resultobj;
35655 fail:
35656 return NULL;
35657 }
35658
35659
35660 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35661 PyObject *resultobj = 0;
35662 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35663 wxString result;
35664 void *argp1 = 0 ;
35665 int res1 = 0 ;
35666 PyObject *swig_obj[1] ;
35667
35668 if (!args) SWIG_fail;
35669 swig_obj[0] = args;
35670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35673 }
35674 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 {
35682 #if wxUSE_UNICODE
35683 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35684 #else
35685 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35686 #endif
35687 }
35688 return resultobj;
35689 fail:
35690 return NULL;
35691 }
35692
35693
35694 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35695 PyObject *resultobj = 0;
35696 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35697 wxString result;
35698 void *argp1 = 0 ;
35699 int res1 = 0 ;
35700 PyObject *swig_obj[1] ;
35701
35702 if (!args) SWIG_fail;
35703 swig_obj[0] = args;
35704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35705 if (!SWIG_IsOK(res1)) {
35706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35707 }
35708 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35709 {
35710 PyThreadState* __tstate = wxPyBeginAllowThreads();
35711 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 {
35716 #if wxUSE_UNICODE
35717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35718 #else
35719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35720 #endif
35721 }
35722 return resultobj;
35723 fail:
35724 return NULL;
35725 }
35726
35727
35728 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35729 PyObject *resultobj = 0;
35730 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35731 wxString result;
35732 void *argp1 = 0 ;
35733 int res1 = 0 ;
35734 PyObject *swig_obj[1] ;
35735
35736 if (!args) SWIG_fail;
35737 swig_obj[0] = args;
35738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35739 if (!SWIG_IsOK(res1)) {
35740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35741 }
35742 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35743 {
35744 PyThreadState* __tstate = wxPyBeginAllowThreads();
35745 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35746 wxPyEndAllowThreads(__tstate);
35747 if (PyErr_Occurred()) SWIG_fail;
35748 }
35749 {
35750 #if wxUSE_UNICODE
35751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35752 #else
35753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35754 #endif
35755 }
35756 return resultobj;
35757 fail:
35758 return NULL;
35759 }
35760
35761
35762 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35763 PyObject *resultobj = 0;
35764 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35765 wxString result;
35766 void *argp1 = 0 ;
35767 int res1 = 0 ;
35768 PyObject *swig_obj[1] ;
35769
35770 if (!args) SWIG_fail;
35771 swig_obj[0] = args;
35772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35773 if (!SWIG_IsOK(res1)) {
35774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35775 }
35776 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 {
35784 #if wxUSE_UNICODE
35785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35786 #else
35787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35788 #endif
35789 }
35790 return resultobj;
35791 fail:
35792 return NULL;
35793 }
35794
35795
35796 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35797 PyObject *resultobj = 0;
35798 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35799 wxString result;
35800 void *argp1 = 0 ;
35801 int res1 = 0 ;
35802 PyObject *swig_obj[1] ;
35803
35804 if (!args) SWIG_fail;
35805 swig_obj[0] = args;
35806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35807 if (!SWIG_IsOK(res1)) {
35808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35809 }
35810 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35811 {
35812 PyThreadState* __tstate = wxPyBeginAllowThreads();
35813 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35814 wxPyEndAllowThreads(__tstate);
35815 if (PyErr_Occurred()) SWIG_fail;
35816 }
35817 {
35818 #if wxUSE_UNICODE
35819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35820 #else
35821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35822 #endif
35823 }
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35831 PyObject *resultobj = 0;
35832 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35833 wxString *arg2 = 0 ;
35834 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35835 wxString result;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838 bool temp2 = false ;
35839 int val3 ;
35840 int ecode3 = 0 ;
35841 PyObject * obj0 = 0 ;
35842 PyObject * obj1 = 0 ;
35843 PyObject * obj2 = 0 ;
35844 char * kwnames[] = {
35845 (char *) "self",(char *) "lang",(char *) "category", NULL
35846 };
35847
35848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35850 if (!SWIG_IsOK(res1)) {
35851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35852 }
35853 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35854 {
35855 arg2 = wxString_in_helper(obj1);
35856 if (arg2 == NULL) SWIG_fail;
35857 temp2 = true;
35858 }
35859 if (obj2) {
35860 ecode3 = SWIG_AsVal_int(obj2, &val3);
35861 if (!SWIG_IsOK(ecode3)) {
35862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35863 }
35864 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35865 }
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35869 wxPyEndAllowThreads(__tstate);
35870 if (PyErr_Occurred()) SWIG_fail;
35871 }
35872 {
35873 #if wxUSE_UNICODE
35874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35875 #else
35876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35877 #endif
35878 }
35879 {
35880 if (temp2)
35881 delete arg2;
35882 }
35883 return resultobj;
35884 fail:
35885 {
35886 if (temp2)
35887 delete arg2;
35888 }
35889 return NULL;
35890 }
35891
35892
35893 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35894 PyObject *resultobj = 0;
35895 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35896 wxString result;
35897 void *argp1 = 0 ;
35898 int res1 = 0 ;
35899 PyObject *swig_obj[1] ;
35900
35901 if (!args) SWIG_fail;
35902 swig_obj[0] = args;
35903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35904 if (!SWIG_IsOK(res1)) {
35905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35906 }
35907 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35908 {
35909 PyThreadState* __tstate = wxPyBeginAllowThreads();
35910 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35911 wxPyEndAllowThreads(__tstate);
35912 if (PyErr_Occurred()) SWIG_fail;
35913 }
35914 {
35915 #if wxUSE_UNICODE
35916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35917 #else
35918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35919 #endif
35920 }
35921 return resultobj;
35922 fail:
35923 return NULL;
35924 }
35925
35926
35927 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35928 PyObject *resultobj = 0;
35929 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35930 wxString *arg2 = 0 ;
35931 void *argp1 = 0 ;
35932 int res1 = 0 ;
35933 bool temp2 = false ;
35934 PyObject * obj0 = 0 ;
35935 PyObject * obj1 = 0 ;
35936 char * kwnames[] = {
35937 (char *) "self",(char *) "prefix", NULL
35938 };
35939
35940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35942 if (!SWIG_IsOK(res1)) {
35943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35944 }
35945 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35946 {
35947 arg2 = wxString_in_helper(obj1);
35948 if (arg2 == NULL) SWIG_fail;
35949 temp2 = true;
35950 }
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
35954 wxPyEndAllowThreads(__tstate);
35955 if (PyErr_Occurred()) SWIG_fail;
35956 }
35957 resultobj = SWIG_Py_Void();
35958 {
35959 if (temp2)
35960 delete arg2;
35961 }
35962 return resultobj;
35963 fail:
35964 {
35965 if (temp2)
35966 delete arg2;
35967 }
35968 return NULL;
35969 }
35970
35971
35972 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35973 PyObject *resultobj = 0;
35974 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35975 wxString result;
35976 void *argp1 = 0 ;
35977 int res1 = 0 ;
35978 PyObject *swig_obj[1] ;
35979
35980 if (!args) SWIG_fail;
35981 swig_obj[0] = args;
35982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35983 if (!SWIG_IsOK(res1)) {
35984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35985 }
35986 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35987 {
35988 PyThreadState* __tstate = wxPyBeginAllowThreads();
35989 result = wxStandardPaths_GetInstallPrefix(arg1);
35990 wxPyEndAllowThreads(__tstate);
35991 if (PyErr_Occurred()) SWIG_fail;
35992 }
35993 {
35994 #if wxUSE_UNICODE
35995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35996 #else
35997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35998 #endif
35999 }
36000 return resultobj;
36001 fail:
36002 return NULL;
36003 }
36004
36005
36006 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36007 PyObject *obj;
36008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36009 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36010 return SWIG_Py_Void();
36011 }
36012
36013 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36014 PyObject *resultobj = 0;
36015 wxEventType arg1 ;
36016 wxPowerEvent *result = 0 ;
36017 int val1 ;
36018 int ecode1 = 0 ;
36019 PyObject * obj0 = 0 ;
36020 char * kwnames[] = {
36021 (char *) "evtType", NULL
36022 };
36023
36024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36025 ecode1 = SWIG_AsVal_int(obj0, &val1);
36026 if (!SWIG_IsOK(ecode1)) {
36027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36028 }
36029 arg1 = static_cast< wxEventType >(val1);
36030 {
36031 PyThreadState* __tstate = wxPyBeginAllowThreads();
36032 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36033 wxPyEndAllowThreads(__tstate);
36034 if (PyErr_Occurred()) SWIG_fail;
36035 }
36036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36037 return resultobj;
36038 fail:
36039 return NULL;
36040 }
36041
36042
36043 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36044 PyObject *resultobj = 0;
36045 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36046 void *argp1 = 0 ;
36047 int res1 = 0 ;
36048 PyObject *swig_obj[1] ;
36049
36050 if (!args) SWIG_fail;
36051 swig_obj[0] = args;
36052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36053 if (!SWIG_IsOK(res1)) {
36054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36055 }
36056 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36057 {
36058 PyThreadState* __tstate = wxPyBeginAllowThreads();
36059 (arg1)->Veto();
36060 wxPyEndAllowThreads(__tstate);
36061 if (PyErr_Occurred()) SWIG_fail;
36062 }
36063 resultobj = SWIG_Py_Void();
36064 return resultobj;
36065 fail:
36066 return NULL;
36067 }
36068
36069
36070 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36071 PyObject *resultobj = 0;
36072 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36073 bool result;
36074 void *argp1 = 0 ;
36075 int res1 = 0 ;
36076 PyObject *swig_obj[1] ;
36077
36078 if (!args) SWIG_fail;
36079 swig_obj[0] = args;
36080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36081 if (!SWIG_IsOK(res1)) {
36082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36083 }
36084 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36085 {
36086 PyThreadState* __tstate = wxPyBeginAllowThreads();
36087 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 {
36092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36093 }
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36101 PyObject *obj;
36102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36103 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36104 return SWIG_Py_Void();
36105 }
36106
36107 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36108 return SWIG_Python_InitShadowInstance(args);
36109 }
36110
36111 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36112 PyObject *resultobj = 0;
36113 wxPowerType result;
36114
36115 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36116 {
36117 PyThreadState* __tstate = wxPyBeginAllowThreads();
36118 result = (wxPowerType)wxGetPowerType();
36119 wxPyEndAllowThreads(__tstate);
36120 if (PyErr_Occurred()) SWIG_fail;
36121 }
36122 resultobj = SWIG_From_int(static_cast< int >(result));
36123 return resultobj;
36124 fail:
36125 return NULL;
36126 }
36127
36128
36129 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36130 PyObject *resultobj = 0;
36131 wxBatteryState result;
36132
36133 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36134 {
36135 PyThreadState* __tstate = wxPyBeginAllowThreads();
36136 result = (wxBatteryState)wxGetBatteryState();
36137 wxPyEndAllowThreads(__tstate);
36138 if (PyErr_Occurred()) SWIG_fail;
36139 }
36140 resultobj = SWIG_From_int(static_cast< int >(result));
36141 return resultobj;
36142 fail:
36143 return NULL;
36144 }
36145
36146
36147 static PyMethodDef SwigMethods[] = {
36148 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36149 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36150 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36151 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36152 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36153 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36154 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36155 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36156 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36160 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36161 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36163 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36164 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36165 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36167 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36168 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36169 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36170 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36171 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36172 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36173 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36174 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36175 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36177 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36178 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36179 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36180 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36182 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36183 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36184 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36185 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36186 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36187 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36188 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36189 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36190 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36191 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36192 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36193 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36194 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36195 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36196 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36197 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36198 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36199 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36200 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36201 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36202 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36203 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36204 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36205 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36206 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36207 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36208 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36209 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36210 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36211 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36212 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36213 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36214 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36215 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36216 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36217 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36218 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36219 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36221 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36222 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36224 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36225 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36226 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36227 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36228 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36229 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36230 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36231 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36232 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36233 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36234 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36235 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36236 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36237 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36238 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36239 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36240 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36241 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36243 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36244 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36245 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36246 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36247 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36248 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36249 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36250 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36251 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36252 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36253 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36254 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36255 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36256 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36257 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36258 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36259 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36260 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36261 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36263 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36264 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36265 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36267 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36268 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36269 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36270 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36271 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36272 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36273 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36274 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36275 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36277 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36280 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36281 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36282 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36284 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36285 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36287 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36288 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36289 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36291 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36292 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36293 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36294 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36295 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36296 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36297 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36298 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36300 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36301 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36302 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36303 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36304 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36306 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36309 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36310 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36314 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36317 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36318 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36319 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36321 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36322 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36324 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36325 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36326 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36328 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36329 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36330 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36331 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36332 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36334 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36335 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36336 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36337 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36340 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36343 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36345 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36346 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36347 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36348 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36349 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36350 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36351 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36352 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36353 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36354 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36355 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36356 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36357 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36358 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36360 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36361 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36362 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36363 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36364 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36367 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36368 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36369 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36371 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36372 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36375 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36379 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36380 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36382 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36383 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36385 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36386 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36387 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36388 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36389 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36390 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36391 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36392 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36393 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36395 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36396 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36397 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36398 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36399 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36402 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36403 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36404 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36406 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36407 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36408 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36410 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36411 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36412 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36413 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36414 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36415 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36416 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36417 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36418 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36419 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36420 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36425 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36426 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36432 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36434 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36435 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36436 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36437 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36438 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36440 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36441 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36444 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36447 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36448 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36449 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36450 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36451 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36452 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36453 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36454 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36455 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36456 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36457 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36458 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36459 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36461 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36462 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36463 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36464 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36465 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36466 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36467 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36468 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36472 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36473 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36474 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36475 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36476 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36477 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36478 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36479 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36480 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36481 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36483 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36484 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36485 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36486 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36487 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36488 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36489 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36490 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36491 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36492 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36493 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36494 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36495 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36496 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36497 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36498 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36499 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36500 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36501 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36502 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36503 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36504 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36505 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36506 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36507 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36508 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36509 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36510 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36511 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36512 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36514 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36515 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36516 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36518 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36519 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36520 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36521 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36522 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36524 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36525 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36526 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36528 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36529 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36530 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36534 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36535 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36538 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36540 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36541 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36544 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36545 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36546 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36549 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36550 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36553 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36554 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36555 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36556 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36557 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36558 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36559 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36560 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36561 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36562 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36563 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36565 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36566 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36567 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36568 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36569 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36570 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36571 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36573 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36577 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36578 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36579 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36580 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36582 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36584 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36589 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36593 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36594 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36595 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36596 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36597 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36600 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36601 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36605 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36606 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36607 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36608 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36611 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36612 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36614 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36615 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36617 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36618 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36619 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36621 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36622 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36623 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36629 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36630 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36631 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36636 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36638 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36640 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36642 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36644 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36645 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36649 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36650 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36652 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36653 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36654 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36656 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36657 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36658 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36659 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36660 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36661 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36662 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36663 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36666 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36669 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36670 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36673 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36674 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36676 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36677 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36678 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36679 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36680 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36681 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36682 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36683 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36684 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36688 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36689 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36690 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36691 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36692 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36696 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36700 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36710 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36716 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36717 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36718 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36719 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36720 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36721 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36722 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36723 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36724 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36725 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36727 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36728 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36736 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36737 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36738 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36742 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36763 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36764 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36765 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36766 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36770 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36771 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36773 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36775 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36777 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36778 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36779 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36780 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36781 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36782 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36783 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36784 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36786 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36788 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36789 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36790 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36792 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36794 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36796 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36798 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36802 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36803 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36805 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36807 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36814 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36818 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36819 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36820 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36824 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36825 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36826 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36827 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36828 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36829 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36831 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36832 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36834 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36836 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36838 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36840 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36841 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36842 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36843 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36844 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36845 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36846 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36847 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36848 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36849 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36850 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36851 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36854 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36857 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36858 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36864 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36865 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36866 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36867 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36868 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36869 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36870 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36871 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36872 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36874 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36875 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36876 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36877 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36878 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36879 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36881 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36882 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36883 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36885 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36886 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36889 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36891 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36893 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36895 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36896 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36898 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36899 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36900 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36902 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36903 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36904 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36905 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36906 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36907 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36908 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36909 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36910 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36911 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36913 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36914 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36915 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36916 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36917 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36918 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36919 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36920 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36922 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36923 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36926 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36927 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36928 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36929 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36930 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36931 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36932 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36933 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36935 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36936 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36937 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36938 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36939 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36940 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36941 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36942 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36943 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36944 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
36945 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
36946 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36947 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36948 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36949 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36950 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36951 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36952 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36953 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36954 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36955 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36956 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36957 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36958 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36959 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36960 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36961 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36962 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36963 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36964 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36965 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36966 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36967 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36968 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36969 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36970 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36971 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36972 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36973 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36974 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36975 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36976 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36977 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36978 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36979 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36980 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36982 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36983 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36984 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36985 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36986 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36988 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36989 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36990 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36991 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36992 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36993 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36994 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36995 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36996 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36997 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36998 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36999 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37000 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37001 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37002 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37003 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37004 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37005 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37006 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37007 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37008 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37009 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37010 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37011 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37012 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37013 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37014 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37015 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37016 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37017 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37018 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37019 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37020 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37021 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37022 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37023 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37024 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37025 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37026 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37027 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37028 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37029 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37030 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37031 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37032 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37033 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37034 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37035 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37036 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37037 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37038 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37039 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37040 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37041 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37042 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37043 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37044 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37045 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37046 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37047 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37048 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37049 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37050 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37051 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37052 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37053 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37054 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37055 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37056 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37057 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37058 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37059 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37060 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37061 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37062 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37063 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37064 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37065 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37066 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37067 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37068 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37069 { NULL, NULL, 0, NULL }
37070 };
37071
37072
37073 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37074
37075 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37076 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37077 }
37078 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37079 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37080 }
37081 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37082 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37083 }
37084 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37085 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37086 }
37087 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37088 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37089 }
37090 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37091 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37092 }
37093 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37094 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37095 }
37096 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37097 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37098 }
37099 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37100 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37101 }
37102 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37103 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37104 }
37105 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37106 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37107 }
37108 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37109 return (void *)((wxEvent *) ((wxPyEvent *) x));
37110 }
37111 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37112 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37113 }
37114 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37115 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37116 }
37117 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37118 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37119 }
37120 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37121 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37122 }
37123 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37124 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37125 }
37126 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37127 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37128 }
37129 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37130 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37131 }
37132 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37133 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37134 }
37135 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37136 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37137 }
37138 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37139 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37140 }
37141 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37142 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37143 }
37144 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37145 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37146 }
37147 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37148 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37149 }
37150 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37151 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37152 }
37153 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37154 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37155 }
37156 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37157 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37158 }
37159 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37160 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37161 }
37162 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37163 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37164 }
37165 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37166 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37167 }
37168 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37169 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37170 }
37171 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37172 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37173 }
37174 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37175 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37176 }
37177 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37178 return (void *)((wxEvent *) ((wxShowEvent *) x));
37179 }
37180 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37181 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37182 }
37183 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37184 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37185 }
37186 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37187 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37188 }
37189 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37190 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37191 }
37192 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37193 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37194 }
37195 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37196 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37197 }
37198 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37199 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37200 }
37201 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37202 return (void *)((wxConfigBase *) ((wxConfig *) x));
37203 }
37204 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37205 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37206 }
37207 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37208 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37209 }
37210 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37211 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37212 }
37213 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37214 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37215 }
37216 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37217 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37218 }
37219 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37220 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37221 }
37222 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37223 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37224 }
37225 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37226 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37227 }
37228 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37229 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37230 }
37231 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37232 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37233 }
37234 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37235 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37236 }
37237 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37238 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37239 }
37240 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37241 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37242 }
37243 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37244 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37245 }
37246 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37247 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37248 }
37249 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37250 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37251 }
37252 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37253 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37254 }
37255 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37256 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37257 }
37258 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37259 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37260 }
37261 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37262 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37263 }
37264 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37265 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37266 }
37267 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37268 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37269 }
37270 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37271 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37272 }
37273 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37274 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37275 }
37276 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37277 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37278 }
37279 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37280 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37281 }
37282 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37283 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37284 }
37285 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37286 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37287 }
37288 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37289 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37290 }
37291 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37292 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37293 }
37294 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37295 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37296 }
37297 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37298 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37299 }
37300 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37301 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37302 }
37303 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37304 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37305 }
37306 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37307 return (void *)((wxObject *) ((wxSizerItem *) x));
37308 }
37309 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37310 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37311 }
37312 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37313 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37314 }
37315 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37316 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37317 }
37318 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37319 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37320 }
37321 static void *_p_wxSizerTo_p_wxObject(void *x) {
37322 return (void *)((wxObject *) ((wxSizer *) x));
37323 }
37324 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37325 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37326 }
37327 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37328 return (void *)((wxObject *) ((wxFileHistory *) x));
37329 }
37330 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37331 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37332 }
37333 static void *_p_wxEventTo_p_wxObject(void *x) {
37334 return (void *)((wxObject *) ((wxEvent *) x));
37335 }
37336 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37337 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37338 }
37339 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37340 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37341 }
37342 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37343 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37344 }
37345 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37346 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37347 }
37348 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37349 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37350 }
37351 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37352 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37353 }
37354 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37355 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37356 }
37357 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37358 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37359 }
37360 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37361 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37362 }
37363 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37364 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37365 }
37366 static void *_p_wxControlTo_p_wxObject(void *x) {
37367 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37368 }
37369 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37370 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37371 }
37372 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37373 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37374 }
37375 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37376 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37377 }
37378 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37379 return (void *)((wxObject *) ((wxFSFile *) x));
37380 }
37381 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37382 return (void *)((wxObject *) ((wxClipboard *) x));
37383 }
37384 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37385 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37386 }
37387 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37388 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37389 }
37390 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37391 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37392 }
37393 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37394 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37395 }
37396 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37397 return (void *)((wxObject *) ((wxToolTip *) x));
37398 }
37399 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37400 return (void *)((wxObject *) ((wxMenuItem *) x));
37401 }
37402 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37403 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37404 }
37405 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37406 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37407 }
37408 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37409 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37410 }
37411 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37412 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37413 }
37414 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37415 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37416 }
37417 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37418 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37419 }
37420 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37421 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37422 }
37423 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37424 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37425 }
37426 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37427 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37428 }
37429 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37430 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37431 }
37432 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37433 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37434 }
37435 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37436 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37437 }
37438 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37439 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37440 }
37441 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37442 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37443 }
37444 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37445 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37446 }
37447 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37448 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37449 }
37450 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37451 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37452 }
37453 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37454 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37455 }
37456 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37457 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37458 }
37459 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37460 return (void *)((wxObject *) ((wxImageHandler *) x));
37461 }
37462 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37463 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37464 }
37465 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37466 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37467 }
37468 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37469 return (void *)((wxObject *) ((wxEvtHandler *) x));
37470 }
37471 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37472 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37473 }
37474 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37475 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37476 }
37477 static void *_p_wxImageTo_p_wxObject(void *x) {
37478 return (void *)((wxObject *) ((wxImage *) x));
37479 }
37480 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37481 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37482 }
37483 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37484 return (void *)((wxObject *) ((wxSystemOptions *) x));
37485 }
37486 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37487 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37488 }
37489 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37490 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37491 }
37492 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37493 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37494 }
37495 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37496 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37497 }
37498 static void *_p_wxWindowTo_p_wxObject(void *x) {
37499 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37500 }
37501 static void *_p_wxMenuTo_p_wxObject(void *x) {
37502 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37503 }
37504 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37505 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37506 }
37507 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37508 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37509 }
37510 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37511 return (void *)((wxObject *) ((wxFileSystem *) x));
37512 }
37513 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37514 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37515 }
37516 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37517 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37518 }
37519 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37520 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37521 }
37522 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37523 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37524 }
37525 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37526 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37527 }
37528 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37529 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37530 }
37531 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37532 return (void *)((wxObject *) ((wxBusyInfo *) x));
37533 }
37534 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37535 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37536 }
37537 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37538 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37539 }
37540 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37541 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37542 }
37543 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37544 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37545 }
37546 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37547 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37548 }
37549 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37550 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37551 }
37552 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37553 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37554 }
37555 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37556 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37557 }
37558 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37559 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37560 }
37561 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37562 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37563 }
37564 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37565 return (void *)((wxLog *) ((wxLogBuffer *) x));
37566 }
37567 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37568 return (void *)((wxLog *) ((wxLogStderr *) x));
37569 }
37570 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37571 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37572 }
37573 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37574 return (void *)((wxLog *) ((wxLogWindow *) x));
37575 }
37576 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37577 return (void *)((wxLog *) ((wxLogChain *) x));
37578 }
37579 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37580 return (void *)((wxLog *) ((wxLogGui *) x));
37581 }
37582 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37583 return (void *)((wxLog *) ((wxPyLog *) x));
37584 }
37585 static void *_p_wxControlTo_p_wxWindow(void *x) {
37586 return (void *)((wxWindow *) ((wxControl *) x));
37587 }
37588 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37589 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37590 }
37591 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37592 return (void *)((wxWindow *) ((wxMenuBar *) x));
37593 }
37594 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37595 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37596 }
37597 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37598 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37599 }
37600 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37601 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};
37602 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37603 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37604 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37605 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37606 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37607 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37608 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37609 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37610 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37611 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37612 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37613 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37614 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37615 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37616 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37617 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37618 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37619 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37620 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37621 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37622 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37623 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37624 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37625 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37626 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37627 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37628 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37629 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37630 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37631 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37632 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37633 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37634 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37635 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37636 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37637 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37638 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37639 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37640 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37641 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37642 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37643 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37644 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37645 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37646 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37647 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37648 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37649 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37650 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37651 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37652 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37653 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37654 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37655 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37656 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37657 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37658 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37659 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37660 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37661 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37662 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37663 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37664 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37665 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37666 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37667 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37668 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37669 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37670 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37671 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37672 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37673 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37674 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37675 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37676 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37677 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37678 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37679 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37680 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37681 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37682 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37683 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37684 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37685 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37686 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37687 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37688 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37689 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37690 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37691 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37692 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37693 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37694 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37695 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37696 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37697 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37698 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37699 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37700 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37701 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37702 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37703 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37704 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37705 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37706 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37707 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37708 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37709 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37710 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37711 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37712 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37713 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37714 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37715 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37716 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37717 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37718 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37719 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37720 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37721 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37722 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37723 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37724 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37725 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37726 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37727 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37728 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37729 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37730 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37731 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37732 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37733 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37734 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37735 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37736 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37737 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37738 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37739 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37740 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37741 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37742 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37743 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37744 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37745 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37746 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37747 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37748 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37749 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37750 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37751 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37752 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37753 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37754 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37755 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37756 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37757 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37758 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37759 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37760 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37761 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37762 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37763 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37764 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37765 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37766 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37767 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37768 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37769 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37770 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37771 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37772
37773 static swig_type_info *swig_type_initial[] = {
37774 &_swigt__p_char,
37775 &_swigt__p_form_ops_t,
37776 &_swigt__p_int,
37777 &_swigt__p_unsigned_char,
37778 &_swigt__p_unsigned_int,
37779 &_swigt__p_unsigned_long,
37780 &_swigt__p_void,
37781 &_swigt__p_wxANIHandler,
37782 &_swigt__p_wxAcceleratorTable,
37783 &_swigt__p_wxActivateEvent,
37784 &_swigt__p_wxArrayString,
37785 &_swigt__p_wxBMPHandler,
37786 &_swigt__p_wxBitmap,
37787 &_swigt__p_wxBitmapDataObject,
37788 &_swigt__p_wxBoxSizer,
37789 &_swigt__p_wxBusyCursor,
37790 &_swigt__p_wxBusyInfo,
37791 &_swigt__p_wxCURHandler,
37792 &_swigt__p_wxCaret,
37793 &_swigt__p_wxChar,
37794 &_swigt__p_wxChildFocusEvent,
37795 &_swigt__p_wxClipboard,
37796 &_swigt__p_wxClipboardLocker,
37797 &_swigt__p_wxClipboardTextEvent,
37798 &_swigt__p_wxCloseEvent,
37799 &_swigt__p_wxColour,
37800 &_swigt__p_wxCommandEvent,
37801 &_swigt__p_wxConfig,
37802 &_swigt__p_wxConfigBase,
37803 &_swigt__p_wxConfigPathChanger,
37804 &_swigt__p_wxContextMenuEvent,
37805 &_swigt__p_wxControl,
37806 &_swigt__p_wxControlWithItems,
37807 &_swigt__p_wxCursor,
37808 &_swigt__p_wxCustomDataObject,
37809 &_swigt__p_wxDC,
37810 &_swigt__p_wxDataFormat,
37811 &_swigt__p_wxDataObject,
37812 &_swigt__p_wxDataObjectComposite,
37813 &_swigt__p_wxDataObjectSimple,
37814 &_swigt__p_wxDateEvent,
37815 &_swigt__p_wxDateSpan,
37816 &_swigt__p_wxDateTime,
37817 &_swigt__p_wxDateTime__TimeZone,
37818 &_swigt__p_wxDisplay,
37819 &_swigt__p_wxDisplayChangedEvent,
37820 &_swigt__p_wxDropFilesEvent,
37821 &_swigt__p_wxDuplexMode,
37822 &_swigt__p_wxEraseEvent,
37823 &_swigt__p_wxEvent,
37824 &_swigt__p_wxEvtHandler,
37825 &_swigt__p_wxFSFile,
37826 &_swigt__p_wxFileConfig,
37827 &_swigt__p_wxFileDataObject,
37828 &_swigt__p_wxFileHistory,
37829 &_swigt__p_wxFileSystem,
37830 &_swigt__p_wxFileType,
37831 &_swigt__p_wxFileTypeInfo,
37832 &_swigt__p_wxFlexGridSizer,
37833 &_swigt__p_wxFocusEvent,
37834 &_swigt__p_wxFont,
37835 &_swigt__p_wxFrame,
37836 &_swigt__p_wxGBSizerItem,
37837 &_swigt__p_wxGIFHandler,
37838 &_swigt__p_wxGridBagSizer,
37839 &_swigt__p_wxGridSizer,
37840 &_swigt__p_wxICOHandler,
37841 &_swigt__p_wxIcon,
37842 &_swigt__p_wxIconizeEvent,
37843 &_swigt__p_wxIdleEvent,
37844 &_swigt__p_wxImage,
37845 &_swigt__p_wxImageHandler,
37846 &_swigt__p_wxIndividualLayoutConstraint,
37847 &_swigt__p_wxInitDialogEvent,
37848 &_swigt__p_wxJPEGHandler,
37849 &_swigt__p_wxJoystick,
37850 &_swigt__p_wxJoystickEvent,
37851 &_swigt__p_wxKeyEvent,
37852 &_swigt__p_wxKillError,
37853 &_swigt__p_wxLayoutConstraints,
37854 &_swigt__p_wxLog,
37855 &_swigt__p_wxLogBuffer,
37856 &_swigt__p_wxLogChain,
37857 &_swigt__p_wxLogGui,
37858 &_swigt__p_wxLogNull,
37859 &_swigt__p_wxLogStderr,
37860 &_swigt__p_wxLogTextCtrl,
37861 &_swigt__p_wxLogWindow,
37862 &_swigt__p_wxMaximizeEvent,
37863 &_swigt__p_wxMemorySize,
37864 &_swigt__p_wxMenu,
37865 &_swigt__p_wxMenuBar,
37866 &_swigt__p_wxMenuEvent,
37867 &_swigt__p_wxMenuItem,
37868 &_swigt__p_wxMetafile,
37869 &_swigt__p_wxMetafileDataObject,
37870 &_swigt__p_wxMimeTypesManager,
37871 &_swigt__p_wxMouseCaptureChangedEvent,
37872 &_swigt__p_wxMouseEvent,
37873 &_swigt__p_wxMouseState,
37874 &_swigt__p_wxMoveEvent,
37875 &_swigt__p_wxMutexGuiLocker,
37876 &_swigt__p_wxNavigationKeyEvent,
37877 &_swigt__p_wxNcPaintEvent,
37878 &_swigt__p_wxNotifyEvent,
37879 &_swigt__p_wxObject,
37880 &_swigt__p_wxOutputStream,
37881 &_swigt__p_wxPCXHandler,
37882 &_swigt__p_wxPNGHandler,
37883 &_swigt__p_wxPNMHandler,
37884 &_swigt__p_wxPaintEvent,
37885 &_swigt__p_wxPaletteChangedEvent,
37886 &_swigt__p_wxPaperSize,
37887 &_swigt__p_wxPoint,
37888 &_swigt__p_wxPowerEvent,
37889 &_swigt__p_wxProcessEvent,
37890 &_swigt__p_wxPyApp,
37891 &_swigt__p_wxPyArtProvider,
37892 &_swigt__p_wxPyBitmapDataObject,
37893 &_swigt__p_wxPyCommandEvent,
37894 &_swigt__p_wxPyDataObjectSimple,
37895 &_swigt__p_wxPyDropSource,
37896 &_swigt__p_wxPyDropTarget,
37897 &_swigt__p_wxPyEvent,
37898 &_swigt__p_wxPyFileDropTarget,
37899 &_swigt__p_wxPyImageHandler,
37900 &_swigt__p_wxPyLog,
37901 &_swigt__p_wxPyProcess,
37902 &_swigt__p_wxPySizer,
37903 &_swigt__p_wxPyTextDataObject,
37904 &_swigt__p_wxPyTextDropTarget,
37905 &_swigt__p_wxPyTimer,
37906 &_swigt__p_wxPyTipProvider,
37907 &_swigt__p_wxPyValidator,
37908 &_swigt__p_wxQueryNewPaletteEvent,
37909 &_swigt__p_wxRect,
37910 &_swigt__p_wxScrollEvent,
37911 &_swigt__p_wxScrollWinEvent,
37912 &_swigt__p_wxSetCursorEvent,
37913 &_swigt__p_wxShowEvent,
37914 &_swigt__p_wxSingleInstanceChecker,
37915 &_swigt__p_wxSize,
37916 &_swigt__p_wxSizeEvent,
37917 &_swigt__p_wxSizer,
37918 &_swigt__p_wxSizerItem,
37919 &_swigt__p_wxSound,
37920 &_swigt__p_wxStandardPaths,
37921 &_swigt__p_wxStaticBoxSizer,
37922 &_swigt__p_wxStdDialogButtonSizer,
37923 &_swigt__p_wxStopWatch,
37924 &_swigt__p_wxString,
37925 &_swigt__p_wxSysColourChangedEvent,
37926 &_swigt__p_wxSystemOptions,
37927 &_swigt__p_wxSystemSettings,
37928 &_swigt__p_wxTIFFHandler,
37929 &_swigt__p_wxTextCtrl,
37930 &_swigt__p_wxTextDataObject,
37931 &_swigt__p_wxTimeSpan,
37932 &_swigt__p_wxTimer,
37933 &_swigt__p_wxTimerEvent,
37934 &_swigt__p_wxTimerRunner,
37935 &_swigt__p_wxTipProvider,
37936 &_swigt__p_wxToolTip,
37937 &_swigt__p_wxURLDataObject,
37938 &_swigt__p_wxUpdateUIEvent,
37939 &_swigt__p_wxValidator,
37940 &_swigt__p_wxVideoMode,
37941 &_swigt__p_wxWindow,
37942 &_swigt__p_wxWindowCreateEvent,
37943 &_swigt__p_wxWindowDestroyEvent,
37944 &_swigt__p_wxWindowDisabler,
37945 &_swigt__p_wxXPMHandler,
37946 };
37947
37948 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37949 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37950 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37951 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37952 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37953 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37954 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37955 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37956 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37957 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}};
37958 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37959 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37960 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37961 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37962 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37963 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37964 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37965 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37966 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}};
37967 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37968 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37969 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37970 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37971 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37972 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}};
37973 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37974 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}};
37975 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37976 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37977 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37978 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37979 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37980 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37981 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37982 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37983 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37984 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37985 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37986 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37987 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37988 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37989 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37990 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37991 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37992 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37993 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37994 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37995 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37996 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37997 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37998 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37999 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38000 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38001 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38002 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38003 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38004 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38005 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38006 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38007 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38008 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38009 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38010 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38011 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38012 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38013 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38014 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38015 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38016 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38017 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}};
38018 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38019 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38020 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38021 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38022 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38023 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38024 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}};
38025 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38026 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38027 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38028 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38029 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38030 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38031 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38032 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38033 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38034 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38035 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38036 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}};
38037 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38038 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38039 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38040 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38041 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38042 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38043 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38044 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
38045 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38046 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
38047 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38048 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38049 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38050 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38051 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38052 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38053 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38054 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38055 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38056 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38057 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38058 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38059 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38060 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38061 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38062 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38063 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38064 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38065 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38066 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38067 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38068 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38069 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38070 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38071 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38072 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38073 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38074 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38075 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38076 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38077 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38078 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38079 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38080 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38081 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}};
38082 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38083 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38084 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38085 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38086 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38087 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38088 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38089 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38090 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38091 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}};
38092 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38093 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38094 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38095 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38096 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38097 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38098 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38099 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38100 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38101 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38102 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38103 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38104 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38105 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38106 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38107 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38108 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38109 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}};
38110 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38111 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38112 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38113 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38114 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}};
38115 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38116 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38117 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38118 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}};
38119 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38120
38121 static swig_cast_info *swig_cast_initial[] = {
38122 _swigc__p_char,
38123 _swigc__p_form_ops_t,
38124 _swigc__p_int,
38125 _swigc__p_unsigned_char,
38126 _swigc__p_unsigned_int,
38127 _swigc__p_unsigned_long,
38128 _swigc__p_void,
38129 _swigc__p_wxANIHandler,
38130 _swigc__p_wxAcceleratorTable,
38131 _swigc__p_wxActivateEvent,
38132 _swigc__p_wxArrayString,
38133 _swigc__p_wxBMPHandler,
38134 _swigc__p_wxBitmap,
38135 _swigc__p_wxBitmapDataObject,
38136 _swigc__p_wxBoxSizer,
38137 _swigc__p_wxBusyCursor,
38138 _swigc__p_wxBusyInfo,
38139 _swigc__p_wxCURHandler,
38140 _swigc__p_wxCaret,
38141 _swigc__p_wxChar,
38142 _swigc__p_wxChildFocusEvent,
38143 _swigc__p_wxClipboard,
38144 _swigc__p_wxClipboardLocker,
38145 _swigc__p_wxClipboardTextEvent,
38146 _swigc__p_wxCloseEvent,
38147 _swigc__p_wxColour,
38148 _swigc__p_wxCommandEvent,
38149 _swigc__p_wxConfig,
38150 _swigc__p_wxConfigBase,
38151 _swigc__p_wxConfigPathChanger,
38152 _swigc__p_wxContextMenuEvent,
38153 _swigc__p_wxControl,
38154 _swigc__p_wxControlWithItems,
38155 _swigc__p_wxCursor,
38156 _swigc__p_wxCustomDataObject,
38157 _swigc__p_wxDC,
38158 _swigc__p_wxDataFormat,
38159 _swigc__p_wxDataObject,
38160 _swigc__p_wxDataObjectComposite,
38161 _swigc__p_wxDataObjectSimple,
38162 _swigc__p_wxDateEvent,
38163 _swigc__p_wxDateSpan,
38164 _swigc__p_wxDateTime,
38165 _swigc__p_wxDateTime__TimeZone,
38166 _swigc__p_wxDisplay,
38167 _swigc__p_wxDisplayChangedEvent,
38168 _swigc__p_wxDropFilesEvent,
38169 _swigc__p_wxDuplexMode,
38170 _swigc__p_wxEraseEvent,
38171 _swigc__p_wxEvent,
38172 _swigc__p_wxEvtHandler,
38173 _swigc__p_wxFSFile,
38174 _swigc__p_wxFileConfig,
38175 _swigc__p_wxFileDataObject,
38176 _swigc__p_wxFileHistory,
38177 _swigc__p_wxFileSystem,
38178 _swigc__p_wxFileType,
38179 _swigc__p_wxFileTypeInfo,
38180 _swigc__p_wxFlexGridSizer,
38181 _swigc__p_wxFocusEvent,
38182 _swigc__p_wxFont,
38183 _swigc__p_wxFrame,
38184 _swigc__p_wxGBSizerItem,
38185 _swigc__p_wxGIFHandler,
38186 _swigc__p_wxGridBagSizer,
38187 _swigc__p_wxGridSizer,
38188 _swigc__p_wxICOHandler,
38189 _swigc__p_wxIcon,
38190 _swigc__p_wxIconizeEvent,
38191 _swigc__p_wxIdleEvent,
38192 _swigc__p_wxImage,
38193 _swigc__p_wxImageHandler,
38194 _swigc__p_wxIndividualLayoutConstraint,
38195 _swigc__p_wxInitDialogEvent,
38196 _swigc__p_wxJPEGHandler,
38197 _swigc__p_wxJoystick,
38198 _swigc__p_wxJoystickEvent,
38199 _swigc__p_wxKeyEvent,
38200 _swigc__p_wxKillError,
38201 _swigc__p_wxLayoutConstraints,
38202 _swigc__p_wxLog,
38203 _swigc__p_wxLogBuffer,
38204 _swigc__p_wxLogChain,
38205 _swigc__p_wxLogGui,
38206 _swigc__p_wxLogNull,
38207 _swigc__p_wxLogStderr,
38208 _swigc__p_wxLogTextCtrl,
38209 _swigc__p_wxLogWindow,
38210 _swigc__p_wxMaximizeEvent,
38211 _swigc__p_wxMemorySize,
38212 _swigc__p_wxMenu,
38213 _swigc__p_wxMenuBar,
38214 _swigc__p_wxMenuEvent,
38215 _swigc__p_wxMenuItem,
38216 _swigc__p_wxMetafile,
38217 _swigc__p_wxMetafileDataObject,
38218 _swigc__p_wxMimeTypesManager,
38219 _swigc__p_wxMouseCaptureChangedEvent,
38220 _swigc__p_wxMouseEvent,
38221 _swigc__p_wxMouseState,
38222 _swigc__p_wxMoveEvent,
38223 _swigc__p_wxMutexGuiLocker,
38224 _swigc__p_wxNavigationKeyEvent,
38225 _swigc__p_wxNcPaintEvent,
38226 _swigc__p_wxNotifyEvent,
38227 _swigc__p_wxObject,
38228 _swigc__p_wxOutputStream,
38229 _swigc__p_wxPCXHandler,
38230 _swigc__p_wxPNGHandler,
38231 _swigc__p_wxPNMHandler,
38232 _swigc__p_wxPaintEvent,
38233 _swigc__p_wxPaletteChangedEvent,
38234 _swigc__p_wxPaperSize,
38235 _swigc__p_wxPoint,
38236 _swigc__p_wxPowerEvent,
38237 _swigc__p_wxProcessEvent,
38238 _swigc__p_wxPyApp,
38239 _swigc__p_wxPyArtProvider,
38240 _swigc__p_wxPyBitmapDataObject,
38241 _swigc__p_wxPyCommandEvent,
38242 _swigc__p_wxPyDataObjectSimple,
38243 _swigc__p_wxPyDropSource,
38244 _swigc__p_wxPyDropTarget,
38245 _swigc__p_wxPyEvent,
38246 _swigc__p_wxPyFileDropTarget,
38247 _swigc__p_wxPyImageHandler,
38248 _swigc__p_wxPyLog,
38249 _swigc__p_wxPyProcess,
38250 _swigc__p_wxPySizer,
38251 _swigc__p_wxPyTextDataObject,
38252 _swigc__p_wxPyTextDropTarget,
38253 _swigc__p_wxPyTimer,
38254 _swigc__p_wxPyTipProvider,
38255 _swigc__p_wxPyValidator,
38256 _swigc__p_wxQueryNewPaletteEvent,
38257 _swigc__p_wxRect,
38258 _swigc__p_wxScrollEvent,
38259 _swigc__p_wxScrollWinEvent,
38260 _swigc__p_wxSetCursorEvent,
38261 _swigc__p_wxShowEvent,
38262 _swigc__p_wxSingleInstanceChecker,
38263 _swigc__p_wxSize,
38264 _swigc__p_wxSizeEvent,
38265 _swigc__p_wxSizer,
38266 _swigc__p_wxSizerItem,
38267 _swigc__p_wxSound,
38268 _swigc__p_wxStandardPaths,
38269 _swigc__p_wxStaticBoxSizer,
38270 _swigc__p_wxStdDialogButtonSizer,
38271 _swigc__p_wxStopWatch,
38272 _swigc__p_wxString,
38273 _swigc__p_wxSysColourChangedEvent,
38274 _swigc__p_wxSystemOptions,
38275 _swigc__p_wxSystemSettings,
38276 _swigc__p_wxTIFFHandler,
38277 _swigc__p_wxTextCtrl,
38278 _swigc__p_wxTextDataObject,
38279 _swigc__p_wxTimeSpan,
38280 _swigc__p_wxTimer,
38281 _swigc__p_wxTimerEvent,
38282 _swigc__p_wxTimerRunner,
38283 _swigc__p_wxTipProvider,
38284 _swigc__p_wxToolTip,
38285 _swigc__p_wxURLDataObject,
38286 _swigc__p_wxUpdateUIEvent,
38287 _swigc__p_wxValidator,
38288 _swigc__p_wxVideoMode,
38289 _swigc__p_wxWindow,
38290 _swigc__p_wxWindowCreateEvent,
38291 _swigc__p_wxWindowDestroyEvent,
38292 _swigc__p_wxWindowDisabler,
38293 _swigc__p_wxXPMHandler,
38294 };
38295
38296
38297 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38298
38299 static swig_const_info swig_const_table[] = {
38300 {0, 0, 0, 0.0, 0, 0}};
38301
38302 #ifdef __cplusplus
38303 }
38304 #endif
38305 /* -----------------------------------------------------------------------------
38306 * Type initialization:
38307 * This problem is tough by the requirement that no dynamic
38308 * memory is used. Also, since swig_type_info structures store pointers to
38309 * swig_cast_info structures and swig_cast_info structures store pointers back
38310 * to swig_type_info structures, we need some lookup code at initialization.
38311 * The idea is that swig generates all the structures that are needed.
38312 * The runtime then collects these partially filled structures.
38313 * The SWIG_InitializeModule function takes these initial arrays out of
38314 * swig_module, and does all the lookup, filling in the swig_module.types
38315 * array with the correct data and linking the correct swig_cast_info
38316 * structures together.
38317 *
38318 * The generated swig_type_info structures are assigned staticly to an initial
38319 * array. We just loop though that array, and handle each type individually.
38320 * First we lookup if this type has been already loaded, and if so, use the
38321 * loaded structure instead of the generated one. Then we have to fill in the
38322 * cast linked list. The cast data is initially stored in something like a
38323 * two-dimensional array. Each row corresponds to a type (there are the same
38324 * number of rows as there are in the swig_type_initial array). Each entry in
38325 * a column is one of the swig_cast_info structures for that type.
38326 * The cast_initial array is actually an array of arrays, because each row has
38327 * a variable number of columns. So to actually build the cast linked list,
38328 * we find the array of casts associated with the type, and loop through it
38329 * adding the casts to the list. The one last trick we need to do is making
38330 * sure the type pointer in the swig_cast_info struct is correct.
38331 *
38332 * First off, we lookup the cast->type name to see if it is already loaded.
38333 * There are three cases to handle:
38334 * 1) If the cast->type has already been loaded AND the type we are adding
38335 * casting info to has not been loaded (it is in this module), THEN we
38336 * replace the cast->type pointer with the type pointer that has already
38337 * been loaded.
38338 * 2) If BOTH types (the one we are adding casting info to, and the
38339 * cast->type) are loaded, THEN the cast info has already been loaded by
38340 * the previous module so we just ignore it.
38341 * 3) Finally, if cast->type has not already been loaded, then we add that
38342 * swig_cast_info to the linked list (because the cast->type) pointer will
38343 * be correct.
38344 * ----------------------------------------------------------------------------- */
38345
38346 #ifdef __cplusplus
38347 extern "C" {
38348 #if 0
38349 } /* c-mode */
38350 #endif
38351 #endif
38352
38353 #if 0
38354 #define SWIGRUNTIME_DEBUG
38355 #endif
38356
38357 SWIGRUNTIME void
38358 SWIG_InitializeModule(void *clientdata) {
38359 size_t i;
38360 swig_module_info *module_head;
38361 static int init_run = 0;
38362
38363 clientdata = clientdata;
38364
38365 if (init_run) return;
38366 init_run = 1;
38367
38368 /* Initialize the swig_module */
38369 swig_module.type_initial = swig_type_initial;
38370 swig_module.cast_initial = swig_cast_initial;
38371
38372 /* Try and load any already created modules */
38373 module_head = SWIG_GetModule(clientdata);
38374 if (module_head) {
38375 swig_module.next = module_head->next;
38376 module_head->next = &swig_module;
38377 } else {
38378 /* This is the first module loaded */
38379 swig_module.next = &swig_module;
38380 SWIG_SetModule(clientdata, &swig_module);
38381 }
38382
38383 /* Now work on filling in swig_module.types */
38384 #ifdef SWIGRUNTIME_DEBUG
38385 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38386 #endif
38387 for (i = 0; i < swig_module.size; ++i) {
38388 swig_type_info *type = 0;
38389 swig_type_info *ret;
38390 swig_cast_info *cast;
38391
38392 #ifdef SWIGRUNTIME_DEBUG
38393 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38394 #endif
38395
38396 /* if there is another module already loaded */
38397 if (swig_module.next != &swig_module) {
38398 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38399 }
38400 if (type) {
38401 /* Overwrite clientdata field */
38402 #ifdef SWIGRUNTIME_DEBUG
38403 printf("SWIG_InitializeModule: found type %s\n", type->name);
38404 #endif
38405 if (swig_module.type_initial[i]->clientdata) {
38406 type->clientdata = swig_module.type_initial[i]->clientdata;
38407 #ifdef SWIGRUNTIME_DEBUG
38408 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38409 #endif
38410 }
38411 } else {
38412 type = swig_module.type_initial[i];
38413 }
38414
38415 /* Insert casting types */
38416 cast = swig_module.cast_initial[i];
38417 while (cast->type) {
38418 /* Don't need to add information already in the list */
38419 ret = 0;
38420 #ifdef SWIGRUNTIME_DEBUG
38421 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38422 #endif
38423 if (swig_module.next != &swig_module) {
38424 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38425 #ifdef SWIGRUNTIME_DEBUG
38426 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38427 #endif
38428 }
38429 if (ret) {
38430 if (type == swig_module.type_initial[i]) {
38431 #ifdef SWIGRUNTIME_DEBUG
38432 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38433 #endif
38434 cast->type = ret;
38435 ret = 0;
38436 } else {
38437 /* Check for casting already in the list */
38438 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38439 #ifdef SWIGRUNTIME_DEBUG
38440 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38441 #endif
38442 if (!ocast) ret = 0;
38443 }
38444 }
38445
38446 if (!ret) {
38447 #ifdef SWIGRUNTIME_DEBUG
38448 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38449 #endif
38450 if (type->cast) {
38451 type->cast->prev = cast;
38452 cast->next = type->cast;
38453 }
38454 type->cast = cast;
38455 }
38456 cast++;
38457 }
38458 /* Set entry in modules->types array equal to the type */
38459 swig_module.types[i] = type;
38460 }
38461 swig_module.types[i] = 0;
38462
38463 #ifdef SWIGRUNTIME_DEBUG
38464 printf("**** SWIG_InitializeModule: Cast List ******\n");
38465 for (i = 0; i < swig_module.size; ++i) {
38466 int j = 0;
38467 swig_cast_info *cast = swig_module.cast_initial[i];
38468 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38469 while (cast->type) {
38470 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38471 cast++;
38472 ++j;
38473 }
38474 printf("---- Total casts: %d\n",j);
38475 }
38476 printf("**** SWIG_InitializeModule: Cast List ******\n");
38477 #endif
38478 }
38479
38480 /* This function will propagate the clientdata field of type to
38481 * any new swig_type_info structures that have been added into the list
38482 * of equivalent types. It is like calling
38483 * SWIG_TypeClientData(type, clientdata) a second time.
38484 */
38485 SWIGRUNTIME void
38486 SWIG_PropagateClientData(void) {
38487 size_t i;
38488 swig_cast_info *equiv;
38489 static int init_run = 0;
38490
38491 if (init_run) return;
38492 init_run = 1;
38493
38494 for (i = 0; i < swig_module.size; i++) {
38495 if (swig_module.types[i]->clientdata) {
38496 equiv = swig_module.types[i]->cast;
38497 while (equiv) {
38498 if (!equiv->converter) {
38499 if (equiv->type && !equiv->type->clientdata)
38500 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38501 }
38502 equiv = equiv->next;
38503 }
38504 }
38505 }
38506 }
38507
38508 #ifdef __cplusplus
38509 #if 0
38510 {
38511 /* c-mode */
38512 #endif
38513 }
38514 #endif
38515
38516
38517
38518 #ifdef __cplusplus
38519 extern "C" {
38520 #endif
38521
38522 /* Python-specific SWIG API */
38523 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38524 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38525 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38526
38527 /* -----------------------------------------------------------------------------
38528 * global variable support code.
38529 * ----------------------------------------------------------------------------- */
38530
38531 typedef struct swig_globalvar {
38532 char *name; /* Name of global variable */
38533 PyObject *(*get_attr)(void); /* Return the current value */
38534 int (*set_attr)(PyObject *); /* Set the value */
38535 struct swig_globalvar *next;
38536 } swig_globalvar;
38537
38538 typedef struct swig_varlinkobject {
38539 PyObject_HEAD
38540 swig_globalvar *vars;
38541 } swig_varlinkobject;
38542
38543 SWIGINTERN PyObject *
38544 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38545 return PyString_FromString("<Swig global variables>");
38546 }
38547
38548 SWIGINTERN PyObject *
38549 swig_varlink_str(swig_varlinkobject *v) {
38550 PyObject *str = PyString_FromString("(");
38551 swig_globalvar *var;
38552 for (var = v->vars; var; var=var->next) {
38553 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38554 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38555 }
38556 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38557 return str;
38558 }
38559
38560 SWIGINTERN int
38561 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38562 PyObject *str = swig_varlink_str(v);
38563 fprintf(fp,"Swig global variables ");
38564 fprintf(fp,"%s\n", PyString_AsString(str));
38565 Py_DECREF(str);
38566 return 0;
38567 }
38568
38569 SWIGINTERN void
38570 swig_varlink_dealloc(swig_varlinkobject *v) {
38571 swig_globalvar *var = v->vars;
38572 while (var) {
38573 swig_globalvar *n = var->next;
38574 free(var->name);
38575 free(var);
38576 var = n;
38577 }
38578 }
38579
38580 SWIGINTERN PyObject *
38581 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38582 PyObject *res = NULL;
38583 swig_globalvar *var = v->vars;
38584 while (var) {
38585 if (strcmp(var->name,n) == 0) {
38586 res = (*var->get_attr)();
38587 break;
38588 }
38589 var = var->next;
38590 }
38591 if (res == NULL && !PyErr_Occurred()) {
38592 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38593 }
38594 return res;
38595 }
38596
38597 SWIGINTERN int
38598 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38599 int res = 1;
38600 swig_globalvar *var = v->vars;
38601 while (var) {
38602 if (strcmp(var->name,n) == 0) {
38603 res = (*var->set_attr)(p);
38604 break;
38605 }
38606 var = var->next;
38607 }
38608 if (res == 1 && !PyErr_Occurred()) {
38609 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38610 }
38611 return res;
38612 }
38613
38614 SWIGINTERN PyTypeObject*
38615 swig_varlink_type(void) {
38616 static char varlink__doc__[] = "Swig var link object";
38617 static PyTypeObject varlink_type;
38618 static int type_init = 0;
38619 if (!type_init) {
38620 const PyTypeObject tmp
38621 = {
38622 PyObject_HEAD_INIT(NULL)
38623 0, /* Number of items in variable part (ob_size) */
38624 (char *)"swigvarlink", /* Type name (tp_name) */
38625 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38626 0, /* Itemsize (tp_itemsize) */
38627 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38628 (printfunc) swig_varlink_print, /* Print (tp_print) */
38629 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38630 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38631 0, /* tp_compare */
38632 (reprfunc) swig_varlink_repr, /* tp_repr */
38633 0, /* tp_as_number */
38634 0, /* tp_as_sequence */
38635 0, /* tp_as_mapping */
38636 0, /* tp_hash */
38637 0, /* tp_call */
38638 (reprfunc)swig_varlink_str, /* tp_str */
38639 0, /* tp_getattro */
38640 0, /* tp_setattro */
38641 0, /* tp_as_buffer */
38642 0, /* tp_flags */
38643 varlink__doc__, /* tp_doc */
38644 0, /* tp_traverse */
38645 0, /* tp_clear */
38646 0, /* tp_richcompare */
38647 0, /* tp_weaklistoffset */
38648 #if PY_VERSION_HEX >= 0x02020000
38649 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38650 #endif
38651 #if PY_VERSION_HEX >= 0x02030000
38652 0, /* tp_del */
38653 #endif
38654 #ifdef COUNT_ALLOCS
38655 0,0,0,0 /* tp_alloc -> tp_next */
38656 #endif
38657 };
38658 varlink_type = tmp;
38659 varlink_type.ob_type = &PyType_Type;
38660 type_init = 1;
38661 }
38662 return &varlink_type;
38663 }
38664
38665 /* Create a variable linking object for use later */
38666 SWIGINTERN PyObject *
38667 SWIG_Python_newvarlink(void) {
38668 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38669 if (result) {
38670 result->vars = 0;
38671 }
38672 return ((PyObject*) result);
38673 }
38674
38675 SWIGINTERN void
38676 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38677 swig_varlinkobject *v = (swig_varlinkobject *) p;
38678 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38679 if (gv) {
38680 size_t size = strlen(name)+1;
38681 gv->name = (char *)malloc(size);
38682 if (gv->name) {
38683 strncpy(gv->name,name,size);
38684 gv->get_attr = get_attr;
38685 gv->set_attr = set_attr;
38686 gv->next = v->vars;
38687 }
38688 }
38689 v->vars = gv;
38690 }
38691
38692 SWIGINTERN PyObject *
38693 SWIG_globals() {
38694 static PyObject *_SWIG_globals = 0;
38695 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38696 return _SWIG_globals;
38697 }
38698
38699 /* -----------------------------------------------------------------------------
38700 * constants/methods manipulation
38701 * ----------------------------------------------------------------------------- */
38702
38703 /* Install Constants */
38704 SWIGINTERN void
38705 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38706 PyObject *obj = 0;
38707 size_t i;
38708 for (i = 0; constants[i].type; ++i) {
38709 switch(constants[i].type) {
38710 case SWIG_PY_POINTER:
38711 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38712 break;
38713 case SWIG_PY_BINARY:
38714 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38715 break;
38716 default:
38717 obj = 0;
38718 break;
38719 }
38720 if (obj) {
38721 PyDict_SetItemString(d, constants[i].name, obj);
38722 Py_DECREF(obj);
38723 }
38724 }
38725 }
38726
38727 /* -----------------------------------------------------------------------------*/
38728 /* Fix SwigMethods to carry the callback ptrs when needed */
38729 /* -----------------------------------------------------------------------------*/
38730
38731 SWIGINTERN void
38732 SWIG_Python_FixMethods(PyMethodDef *methods,
38733 swig_const_info *const_table,
38734 swig_type_info **types,
38735 swig_type_info **types_initial) {
38736 size_t i;
38737 for (i = 0; methods[i].ml_name; ++i) {
38738 const char *c = methods[i].ml_doc;
38739 if (c && (c = strstr(c, "swig_ptr: "))) {
38740 int j;
38741 swig_const_info *ci = 0;
38742 const char *name = c + 10;
38743 for (j = 0; const_table[j].type; ++j) {
38744 if (strncmp(const_table[j].name, name,
38745 strlen(const_table[j].name)) == 0) {
38746 ci = &(const_table[j]);
38747 break;
38748 }
38749 }
38750 if (ci) {
38751 size_t shift = (ci->ptype) - types;
38752 swig_type_info *ty = types_initial[shift];
38753 size_t ldoc = (c - methods[i].ml_doc);
38754 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38755 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38756 if (ndoc) {
38757 char *buff = ndoc;
38758 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38759 if (ptr) {
38760 strncpy(buff, methods[i].ml_doc, ldoc);
38761 buff += ldoc;
38762 strncpy(buff, "swig_ptr: ", 10);
38763 buff += 10;
38764 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38765 methods[i].ml_doc = ndoc;
38766 }
38767 }
38768 }
38769 }
38770 }
38771 }
38772
38773 #ifdef __cplusplus
38774 }
38775 #endif
38776
38777 /* -----------------------------------------------------------------------------*
38778 * Partial Init method
38779 * -----------------------------------------------------------------------------*/
38780
38781 #ifdef __cplusplus
38782 extern "C"
38783 #endif
38784 SWIGEXPORT void SWIG_init(void) {
38785 PyObject *m, *d;
38786
38787 /* Fix SwigMethods to carry the callback ptrs when needed */
38788 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38789
38790 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38791 d = PyModule_GetDict(m);
38792
38793 SWIG_InitializeModule(0);
38794 SWIG_InstallConstants(d,swig_const_table);
38795
38796
38797 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38798 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38799 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38800 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38801 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38802 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38803 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38804 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38805 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38806 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38807 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38808 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38809 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38810 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38811 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38812 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38813 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38814 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38815 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38816 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38817 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38818 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38819 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38820 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38821 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38822 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38823 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38824 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38825 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38826 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38827 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38828 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38829 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38830 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38831 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38832 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38833 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38834 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38835 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38836 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38837 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38838 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38839 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38840 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38841 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38842 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38843 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38844 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38845 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38846 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38847 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38848 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38849 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38850 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38851 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38852 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38853 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38854 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38855 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38856 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38857 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38858 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38859 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38860 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38861 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38862 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38863 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38864 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38865 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38866 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38867 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38868 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38869 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38870 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38871 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38872 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38873 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38874 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38875 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38876 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38877 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38878 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38879 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38880 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38881 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38882 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38883 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38884 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38885 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38886 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38887 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38888 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38889 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38890 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38891 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38892 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38893 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38894 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
38895 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
38896 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
38897 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
38898 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
38899 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
38900 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
38901 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
38902 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
38903 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
38904 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
38905 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
38906 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
38907 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
38908 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
38909 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
38910 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
38911 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
38912 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
38913 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
38914 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
38915 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
38916 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
38917 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
38918 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
38919 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
38920 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
38921 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
38922 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
38923 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
38924 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
38925 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
38926 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
38927 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
38928 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
38929 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38930 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38931 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38932 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38933 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38934
38935 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38936
38937 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38938 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38939 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38940 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38941 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38942 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38943 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38944 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38945 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38946 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38947 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38948 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38949 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38950 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38951 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38952 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38953 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38954 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38955 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38956 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38957 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38958 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38959 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38960 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38961 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38962 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38963 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38964 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38965 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38966 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38967 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38968 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38969 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38970 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38971 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38972 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38973 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38974 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38975 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38976 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38977 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38978 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38979 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38980 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38981 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38982 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38983 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38984 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38985 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38986 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38987 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38988 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38989 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38990
38991 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38992
38993 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38994 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38995 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38996 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38997 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38998 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38999 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
39000 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
39001 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
39002 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
39003 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
39004 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
39005 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
39006 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
39007 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
39008 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
39009 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
39010 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
39011 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
39012 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
39013 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
39014 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
39015 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
39016 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
39017 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
39018 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
39019 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
39020 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
39021 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
39022 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
39023 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
39024 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
39025 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
39026 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
39027 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39028 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39029 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39030 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39031 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39032 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39033 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39034 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39035 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39036 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39037 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39038 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39039 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39040 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39041 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39042 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39043 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39044 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39045 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39046 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39047 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39048 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39049 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39050 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39051 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39052 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39053 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39054 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39055 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39056 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39057 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39058 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39059 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39060 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39061 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39062 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39063 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39064 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39065 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39066 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39067 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39068 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39069
39070 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39071
39072 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39073 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39074 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39075 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39076 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39077 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39078 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39079 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39080 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39081 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39082 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39083 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39084 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39085 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39086 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39087 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39088 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39089 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39090 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39091 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39092 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39093 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39094 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39095 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39096 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39097 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39098 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39099 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39100 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39101 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39102 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39103 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39104 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39105 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39106 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39107 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39108 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39109 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39110 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39111 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39112 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39113 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39114 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39115 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39116 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39117 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39118 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39119 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39120 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39121 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39122 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39123 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39124 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39125 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39126 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39127 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39128 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39129 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39130 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39131 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39132 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39133 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39134 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39135 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39136 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39137 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39138 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39139 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39140 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39141 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39142 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39143 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39144 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39145 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39146 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39147 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39148 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39149 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39150 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39151 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39152 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39153 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39154 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39155 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39156 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39157 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39158 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39159 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39160 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39161 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39162 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39163 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39164 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39165 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39166 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39167 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39168 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39169 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39170 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39171 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39172 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39173 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39174 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39175 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39176 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39177 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39178 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39179 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39180 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39181 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39182 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39183 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39184 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39185 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39186 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39187 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39188 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39189 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39190 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39191 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39192 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39193 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39194 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39195 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39196 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39197 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39198 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39199 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39200 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39201 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39202 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39203 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39204 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39205 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39206 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39207 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39208 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39209 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39210 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39211 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39212 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39213 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39214 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39215 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39216 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39217 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39218 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39219 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39220 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39221 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39222 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39223 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39224 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39225 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39226 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39227 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39228 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39229 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39230 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39231 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39232 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39233 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39234 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39235 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39236 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39237 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39238 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39239 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39240 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39241 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39242 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39243 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39244 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39245 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39246 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39247 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39248 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39249 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39250 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39251 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39252 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39253 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39254 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39255 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39256 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39257 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39258 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39259 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39260 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39261 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39262 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39263 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39264 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39265 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39266 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39267 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39268 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39269 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39270 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39271 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39272
39273 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39274 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39275 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39276 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39277
39278 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39279 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39280 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39281 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39282 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39283 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39284 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39285 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39286 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39287 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39288 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39289 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39290 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39291 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39292 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39293 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39294 }
39295
wxWidgets (Impactor)