]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add tests for wxBackingFile.
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent 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_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTIFFHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTextCtrl swig_types[156]
2623 #define SWIGTYPE_p_wxTextDataObject swig_types[157]
2624 #define SWIGTYPE_p_wxTimeSpan swig_types[158]
2625 #define SWIGTYPE_p_wxTimer swig_types[159]
2626 #define SWIGTYPE_p_wxTimerEvent swig_types[160]
2627 #define SWIGTYPE_p_wxTimerRunner swig_types[161]
2628 #define SWIGTYPE_p_wxTipProvider swig_types[162]
2629 #define SWIGTYPE_p_wxToolTip swig_types[163]
2630 #define SWIGTYPE_p_wxURLDataObject swig_types[164]
2631 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[165]
2632 #define SWIGTYPE_p_wxValidator swig_types[166]
2633 #define SWIGTYPE_p_wxVideoMode swig_types[167]
2634 #define SWIGTYPE_p_wxWindow swig_types[168]
2635 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[169]
2636 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDisabler swig_types[171]
2638 #define SWIGTYPE_p_wxXPMHandler swig_types[172]
2639 static swig_type_info *swig_types[174];
2640 static swig_module_info swig_module = {swig_types, 173, 0, 0, 0, 0};
2641 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2642 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2643
2644 /* -------- TYPES TABLE (END) -------- */
2645
2646 #if (PY_VERSION_HEX <= 0x02000000)
2647 # if !defined(SWIG_PYTHON_CLASSIC)
2648 # error "This python version requires to use swig with the '-classic' option"
2649 # endif
2650 #endif
2651 #if (PY_VERSION_HEX <= 0x02020000)
2652 # error "This python version requires to use swig with the '-nomodern' option"
2653 #endif
2654 #if (PY_VERSION_HEX <= 0x02020000)
2655 # error "This python version requires to use swig with the '-nomodernargs' option"
2656 #endif
2657 #ifndef METH_O
2658 # error "This python version requires to use swig with the '-nofastunpack' option"
2659 #endif
2660
2661 /*-----------------------------------------------
2662 @(target):= _misc_.so
2663 ------------------------------------------------*/
2664 #define SWIG_init init_misc_
2665
2666 #define SWIG_name "_misc_"
2667
2668 #define SWIGVERSION 0x010329
2669
2670
2671 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2672 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2673
2674
2675 #include <stdexcept>
2676
2677
2678 namespace swig {
2679 class PyObject_ptr {
2680 protected:
2681 PyObject *_obj;
2682
2683 public:
2684 PyObject_ptr() :_obj(0)
2685 {
2686 }
2687
2688 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2689 {
2690 Py_XINCREF(_obj);
2691 }
2692
2693 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2694 {
2695 if (initial_ref) Py_XINCREF(_obj);
2696 }
2697
2698 PyObject_ptr & operator=(const PyObject_ptr& item)
2699 {
2700 Py_XINCREF(item._obj);
2701 Py_XDECREF(_obj);
2702 _obj = item._obj;
2703 return *this;
2704 }
2705
2706 ~PyObject_ptr()
2707 {
2708 Py_XDECREF(_obj);
2709 }
2710
2711 operator PyObject *() const
2712 {
2713 return _obj;
2714 }
2715
2716 PyObject *operator->() const
2717 {
2718 return _obj;
2719 }
2720 };
2721 }
2722
2723
2724 namespace swig {
2725 struct PyObject_var : PyObject_ptr {
2726 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2727
2728 PyObject_var & operator = (PyObject* obj)
2729 {
2730 Py_XDECREF(_obj);
2731 _obj = obj;
2732 return *this;
2733 }
2734 };
2735 }
2736
2737
2738 #include "wx/wxPython/wxPython.h"
2739 #include "wx/wxPython/pyclasses.h"
2740 #include "wx/wxPython/pyistream.h"
2741
2742 static const wxString wxPyEmptyString(wxEmptyString);
2743
2744
2745
2746 #define SWIG_From_long PyInt_FromLong
2747
2748
2749 SWIGINTERNINLINE PyObject *
2750 SWIG_From_int (int value)
2751 {
2752 return SWIG_From_long (value);
2753 }
2754
2755
2756 #include <limits.h>
2757 #ifndef LLONG_MIN
2758 # define LLONG_MIN LONG_LONG_MIN
2759 #endif
2760 #ifndef LLONG_MAX
2761 # define LLONG_MAX LONG_LONG_MAX
2762 #endif
2763 #ifndef ULLONG_MAX
2764 # define ULLONG_MAX ULONG_LONG_MAX
2765 #endif
2766
2767
2768 SWIGINTERN int
2769 SWIG_AsVal_long (PyObject* obj, long* val)
2770 {
2771 if (PyNumber_Check(obj)) {
2772 if (val) *val = PyInt_AsLong(obj);
2773 return SWIG_OK;
2774 }
2775 return SWIG_TypeError;
2776 }
2777
2778
2779 SWIGINTERN int
2780 SWIG_AsVal_int (PyObject * obj, int *val)
2781 {
2782 long v;
2783 int res = SWIG_AsVal_long (obj, &v);
2784 if (SWIG_IsOK(res)) {
2785 if ((v < INT_MIN || v > INT_MAX)) {
2786 return SWIG_OverflowError;
2787 } else {
2788 if (val) *val = static_cast< int >(v);
2789 }
2790 }
2791 return res;
2792 }
2793
2794 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2795
2796 #include <wx/stockitem.h>
2797
2798 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2799 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2800 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2801
2802 SWIGINTERN int
2803 SWIG_AsVal_bool (PyObject *obj, bool *val)
2804 {
2805 if (obj == Py_True) {
2806 if (val) *val = true;
2807 return SWIG_OK;
2808 } else if (obj == Py_False) {
2809 if (val) *val = false;
2810 return SWIG_OK;
2811 } else {
2812 long v = 0;
2813 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2814 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2815 return res;
2816 }
2817 }
2818
2819
2820 wxMemorySize wxGetFreeMemory()
2821 { wxPyRaiseNotImplemented(); return 0; }
2822
2823
2824 SWIGINTERN int
2825 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2826 {
2827 long v = 0;
2828 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2829 return SWIG_TypeError;
2830 }
2831 else if (val)
2832 *val = (unsigned long)v;
2833 return SWIG_OK;
2834 }
2835
2836
2837 SWIGINTERNINLINE PyObject*
2838 SWIG_From_unsigned_SS_long (unsigned long value)
2839 {
2840 return (value > LONG_MAX) ?
2841 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2842 }
2843
2844
2845 void* wxGetXDisplay()
2846 {
2847 #ifdef __WXGTK__
2848 return wxGetDisplay();
2849 #else
2850 return NULL;
2851 #endif
2852 }
2853
2854
2855 wxWindow* FindWindowAtPointer() {
2856 wxPoint unused;
2857 return wxFindWindowAtPointer(unused);
2858 }
2859
2860
2861 void wxWakeUpMainThread() {}
2862
2863
2864 bool wxThread_IsMain() {
2865 #ifdef WXP_WITH_THREAD
2866 return wxThread::IsMain();
2867 #else
2868 return true;
2869 #endif
2870 }
2871
2872 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2873 delete self;
2874 }
2875
2876 #include <wx/snglinst.h>
2877
2878
2879 #ifdef __WXMSW__
2880 #include <wx/msw/private.h>
2881 #include <wx/dynload.h>
2882 #endif
2883
2884
2885
2886 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2887 #if 0
2888 , int method
2889 #endif
2890 )
2891 {
2892 #ifdef __WXMSW__
2893 #if 0
2894 switch (method)
2895 {
2896 case 1:
2897 // This one only partially works. Appears to be an undocumented
2898 // "standard" convention that not all widgets adhear to. For
2899 // example, for some widgets backgrounds or non-client areas may
2900 // not be painted.
2901 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2902 break;
2903
2904 case 2:
2905 #endif
2906 // This one works much better, nearly all widgets and their
2907 // children are captured correctly[**]. Prior to the big
2908 // background erase changes that Vadim did in 2004-2005 this
2909 // method failed badly on XP with Themes activated, most native
2910 // widgets draw only partially, if at all. Without themes it
2911 // worked just like on Win2k. After those changes this method
2912 // works very well.
2913 //
2914 // ** For example the radio buttons in a wxRadioBox are not its
2915 // children by default, but you can capture it via the panel
2916 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2917 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2918 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2919 PRF_ERASEBKGND | PRF_OWNED );
2920 return true;
2921 #if 0
2922 break;
2923
2924 case 3:
2925 // This one is only defined in the latest SDK and is only
2926 // available on XP. MSDN says it is similar to sending WM_PRINT
2927 // so I expect that it will work similar to the above. Since it
2928 // is avaialble only on XP, it can't be compiled like this and
2929 // will have to be loaded dynamically.
2930 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2931
2932 // fall through
2933
2934 case 4:
2935 // Use PrintWindow if available, or fallback to WM_PRINT
2936 // otherwise. Unfortunately using PrintWindow is even worse than
2937 // WM_PRINT. For most native widgets nothing is drawn to the dc
2938 // at all, with or without Themes.
2939 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2940 static bool s_triedToLoad = false;
2941 static PrintWindow_t pfnPrintWindow = NULL;
2942 if ( !s_triedToLoad )
2943 {
2944
2945 s_triedToLoad = true;
2946 wxDynamicLibrary dllUser32(_T("user32.dll"));
2947 if ( dllUser32.IsLoaded() )
2948 {
2949 wxLogNull nolog; // Don't report errors here
2950 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2951 }
2952 }
2953 if (pfnPrintWindow)
2954 {
2955 //printf("Using PrintWindow\n");
2956 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2957 }
2958 else
2959 {
2960 //printf("Using WM_PRINT\n");
2961 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2962 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2963 PRF_ERASEBKGND | PRF_OWNED );
2964 }
2965 }
2966 #endif // 0
2967 #else
2968 return false;
2969 #endif // __WXMSW__
2970 }
2971
2972
2973
2974 #include <wx/tipdlg.h>
2975
2976
2977 SWIGINTERNINLINE PyObject *
2978 SWIG_From_size_t (size_t value)
2979 {
2980 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2981 }
2982
2983
2984 class wxPyTipProvider : public wxTipProvider {
2985 public:
2986 wxPyTipProvider(size_t currentTip)
2987 : wxTipProvider(currentTip) {}
2988
2989 DEC_PYCALLBACK_STRING__pure(GetTip);
2990 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2991 PYPRIVATE;
2992 };
2993
2994 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2995 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2996
2997
2998 SWIGINTERNINLINE int
2999 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3000 {
3001 unsigned long v;
3002 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3003 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3004 return res;
3005 }
3006
3007
3008 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3009
3010 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3011
3012 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3013 : wxTimer(owner, id)
3014 {
3015 if (owner == NULL)
3016 SetOwner(this);
3017 }
3018
3019
3020 SWIGINTERN swig_type_info*
3021 SWIG_pchar_descriptor()
3022 {
3023 static int init = 0;
3024 static swig_type_info* info = 0;
3025 if (!init) {
3026 info = SWIG_TypeQuery("_p_char");
3027 init = 1;
3028 }
3029 return info;
3030 }
3031
3032
3033 SWIGINTERNINLINE PyObject *
3034 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3035 {
3036 if (carray) {
3037 if (size > INT_MAX) {
3038 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3039 return pchar_descriptor ?
3040 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3041 } else {
3042 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3043 }
3044 } else {
3045 return SWIG_Py_Void();
3046 }
3047 }
3048
3049
3050 SWIGINTERNINLINE PyObject *
3051 SWIG_FromCharPtr(const char *cptr)
3052 {
3053 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3054 }
3055
3056
3057 SWIGINTERN int
3058 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3059 {
3060 unsigned long v;
3061 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3062 if (SWIG_IsOK(res)) {
3063 if ((v > UINT_MAX)) {
3064 return SWIG_OverflowError;
3065 } else {
3066 if (val) *val = static_cast< unsigned int >(v);
3067 }
3068 }
3069 return res;
3070 }
3071
3072 SWIGINTERN wxString wxLog_TimeStamp(){
3073 wxString msg;
3074 wxLog::TimeStamp(&msg);
3075 return msg;
3076 }
3077 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3078 // Make some wrappers that double any % signs so they are 'escaped'
3079 void wxPyLogFatalError(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogFatalError(m);
3084 }
3085
3086 void wxPyLogError(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogError(m);
3091 }
3092
3093 void wxPyLogWarning(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogWarning(m);
3098 }
3099
3100 void wxPyLogMessage(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogMessage(m);
3105 }
3106
3107 void wxPyLogInfo(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogInfo(m);
3112 }
3113
3114 void wxPyLogDebug(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogDebug(m);
3119 }
3120
3121 void wxPyLogVerbose(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogVerbose(m);
3126 }
3127
3128 void wxPyLogStatus(const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogStatus(m);
3133 }
3134
3135 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogStatus(pFrame, m);
3140 }
3141
3142 void wxPyLogSysError(const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogSysError(m);
3147 }
3148
3149 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogGeneric(level, m);
3154 }
3155
3156 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogTrace(mask, m);
3161 }
3162
3163 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3164 {
3165 wxString m(msg);
3166 m.Replace(wxT("%"), wxT("%%"));
3167 wxLogTrace(mask, m);
3168 }
3169
3170
3171
3172 // A wxLog class that can be derived from in wxPython
3173 class wxPyLog : public wxLog {
3174 public:
3175 wxPyLog() : wxLog() {}
3176
3177 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3178 bool found;
3179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3180 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3181 PyObject* s = wx2PyString(szString);
3182 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3183 Py_DECREF(s);
3184 }
3185 wxPyEndBlockThreads(blocked);
3186 if (! found)
3187 wxLog::DoLog(level, szString, t);
3188 }
3189
3190 virtual void DoLogString(const wxChar *szString, time_t t) {
3191 bool found;
3192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3193 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3194 PyObject* s = wx2PyString(szString);
3195 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3196 Py_DECREF(s);
3197 }
3198 wxPyEndBlockThreads(blocked);
3199 if (! found)
3200 wxLog::DoLogString(szString, t);
3201 }
3202
3203 DEC_PYCALLBACK_VOID_(Flush);
3204 PYPRIVATE;
3205 };
3206 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3207
3208
3209
3210
3211 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3212
3213
3214 #include <wx/joystick.h>
3215
3216
3217 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3218 // A C++ stub class for wxJoystick for platforms that don't have it.
3219 class wxJoystick : public wxObject {
3220 public:
3221 wxJoystick(int joystick = wxJOYSTICK1) {
3222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3223 PyErr_SetString(PyExc_NotImplementedError,
3224 "wxJoystick is not available on this platform.");
3225 wxPyEndBlockThreads(blocked);
3226 }
3227 wxPoint GetPosition() { return wxPoint(-1,-1); }
3228 int GetZPosition() { return -1; }
3229 int GetButtonState() { return -1; }
3230 int GetPOVPosition() { return -1; }
3231 int GetPOVCTSPosition() { return -1; }
3232 int GetRudderPosition() { return -1; }
3233 int GetUPosition() { return -1; }
3234 int GetVPosition() { return -1; }
3235 int GetMovementThreshold() { return -1; }
3236 void SetMovementThreshold(int threshold) {}
3237
3238 bool IsOk(void) { return false; }
3239 int GetNumberJoysticks() { return -1; }
3240 int GetManufacturerId() { return -1; }
3241 int GetProductId() { return -1; }
3242 wxString GetProductName() { return wxEmptyString; }
3243 int GetXMin() { return -1; }
3244 int GetYMin() { return -1; }
3245 int GetZMin() { return -1; }
3246 int GetXMax() { return -1; }
3247 int GetYMax() { return -1; }
3248 int GetZMax() { return -1; }
3249 int GetNumberButtons() { return -1; }
3250 int GetNumberAxes() { return -1; }
3251 int GetMaxButtons() { return -1; }
3252 int GetMaxAxes() { return -1; }
3253 int GetPollingMin() { return -1; }
3254 int GetPollingMax() { return -1; }
3255 int GetRudderMin() { return -1; }
3256 int GetRudderMax() { return -1; }
3257 int GetUMin() { return -1; }
3258 int GetUMax() { return -1; }
3259 int GetVMin() { return -1; }
3260 int GetVMax() { return -1; }
3261
3262 bool HasRudder() { return false; }
3263 bool HasZ() { return false; }
3264 bool HasU() { return false; }
3265 bool HasV() { return false; }
3266 bool HasPOV() { return false; }
3267 bool HasPOV4Dir() { return false; }
3268 bool HasPOVCTS() { return false; }
3269
3270 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3271 bool ReleaseCapture() { return false; }
3272 };
3273 #endif
3274
3275
3276 #include <wx/sound.h>
3277
3278
3279 #if !wxUSE_SOUND
3280 // A C++ stub class for wxWave for platforms that don't have it.
3281 class wxSound : public wxObject
3282 {
3283 public:
3284 wxSound() {
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 PyErr_SetString(PyExc_NotImplementedError,
3287 "wxSound is not available on this platform.");
3288 wxPyEndBlockThreads(blocked);
3289 }
3290 wxSound(const wxString&/*, bool*/) {
3291 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3292 PyErr_SetString(PyExc_NotImplementedError,
3293 "wxSound is not available on this platform.");
3294 wxPyEndBlockThreads(blocked);
3295 }
3296 wxSound(int, const wxByte*) {
3297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3298 PyErr_SetString(PyExc_NotImplementedError,
3299 "wxSound is not available on this platform.");
3300 wxPyEndBlockThreads(blocked);
3301 }
3302
3303 ~wxSound() {};
3304
3305 bool Create(const wxString&/*, bool*/) { return false; }
3306 bool Create(int, const wxByte*) { return false; };
3307 bool IsOk() { return false; };
3308 bool Play(unsigned) const { return false; }
3309 static bool Play(const wxString&, unsigned) { return false; }
3310 static void Stop() {}
3311 };
3312
3313 #endif
3314
3315 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3316 if (fileName.Length() == 0)
3317 return new wxSound;
3318 else
3319 return new wxSound(fileName);
3320 }
3321 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3322 unsigned char* buffer; int size;
3323 wxSound *sound = NULL;
3324
3325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3326 if (!PyArg_Parse(data, "t#", &buffer, &size))
3327 goto done;
3328 sound = new wxSound(size, buffer);
3329 done:
3330 wxPyEndBlockThreads(blocked);
3331 return sound;
3332 }
3333 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3334 #ifndef __WXMAC__
3335 unsigned char* buffer;
3336 int size;
3337 bool rv = false;
3338
3339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3340 if (!PyArg_Parse(data, "t#", &buffer, &size))
3341 goto done;
3342 rv = self->Create(size, buffer);
3343 done:
3344 wxPyEndBlockThreads(blocked);
3345 return rv;
3346 #else
3347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3348 PyErr_SetString(PyExc_NotImplementedError,
3349 "Create from data is not available on this platform.");
3350 wxPyEndBlockThreads(blocked);
3351 return false;
3352 #endif
3353 }
3354
3355 #include <wx/mimetype.h>
3356
3357 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3358 wxString str;
3359 if (self->GetMimeType(&str))
3360 return wx2PyString(str);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3365 wxArrayString arr;
3366 if (self->GetMimeTypes(arr))
3367 return wxArrayString2PyList_helper(arr);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3372 wxArrayString arr;
3373 if (self->GetExtensions(arr))
3374 return wxArrayString2PyList_helper(arr);
3375 else
3376 RETURN_NONE();
3377 }
3378 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3379 wxIconLocation loc;
3380 if (self->GetIcon(&loc))
3381 return new wxIcon(loc);
3382 else
3383 return NULL;
3384 }
3385 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3386 wxIconLocation loc;
3387 if (self->GetIcon(&loc)) {
3388 wxString iconFile = loc.GetFileName();
3389 int iconIndex = -1;
3390
3391
3392
3393 // Make a tuple and put the values in it
3394 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3395 PyObject* tuple = PyTuple_New(3);
3396 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3397 wxT("wxIcon"), true));
3398 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3399 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3400 wxPyEndBlockThreads(blocked);
3401 return tuple;
3402 }
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3407 wxString str;
3408 if (self->GetDescription(&str))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxString str;
3415 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxString str;
3422 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3423 return wx2PyString(str);
3424 else
3425 RETURN_NONE();
3426 }
3427 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3428 wxArrayString verbs;
3429 wxArrayString commands;
3430 if (self->GetAllCommands(&verbs, &commands,
3431 wxFileType::MessageParameters(filename, mimetype))) {
3432 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3433 PyObject* tuple = PyTuple_New(2);
3434 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3435 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3436 wxPyEndBlockThreads(blocked);
3437 return tuple;
3438 }
3439 else
3440 RETURN_NONE();
3441 }
3442 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3443 return wxFileType::ExpandCommand(command,
3444 wxFileType::MessageParameters(filename, mimetype));
3445 }
3446 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3447 wxArrayString arr;
3448 self->EnumAllFileTypes(arr);
3449 return wxArrayString2PyList_helper(arr);
3450 }
3451
3452 #include <wx/artprov.h>
3453
3454 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3455 static const wxString wxPyART_MENU(wxART_MENU);
3456 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3457 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3458 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3459 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3460 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3461 static const wxString wxPyART_OTHER(wxART_OTHER);
3462 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3463 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3464 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3465 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3466 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3467 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3468 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3469 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3470 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3471 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3472 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3473 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3474 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3475 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3476 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3477 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3478 static const wxString wxPyART_PRINT(wxART_PRINT);
3479 static const wxString wxPyART_HELP(wxART_HELP);
3480 static const wxString wxPyART_TIP(wxART_TIP);
3481 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3482 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3483 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3484 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3485 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3486 static const wxString wxPyART_CDROM(wxART_CDROM);
3487 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3488 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3489 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3490 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3491 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3492 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3493 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3494 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3495 static const wxString wxPyART_ERROR(wxART_ERROR);
3496 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3497 static const wxString wxPyART_WARNING(wxART_WARNING);
3498 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3499 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3500 static const wxString wxPyART_COPY(wxART_COPY);
3501 static const wxString wxPyART_CUT(wxART_CUT);
3502 static const wxString wxPyART_PASTE(wxART_PASTE);
3503 static const wxString wxPyART_DELETE(wxART_DELETE);
3504 static const wxString wxPyART_NEW(wxART_NEW);
3505 static const wxString wxPyART_UNDO(wxART_UNDO);
3506 static const wxString wxPyART_REDO(wxART_REDO);
3507 static const wxString wxPyART_QUIT(wxART_QUIT);
3508 static const wxString wxPyART_FIND(wxART_FIND);
3509 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3510 // Python aware wxArtProvider
3511 class wxPyArtProvider : public wxArtProvider {
3512 public:
3513
3514 virtual wxBitmap CreateBitmap(const wxArtID& id,
3515 const wxArtClient& client,
3516 const wxSize& size) {
3517 wxBitmap rval = wxNullBitmap;
3518 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3519 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3520 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3521 PyObject* ro;
3522 wxBitmap* ptr;
3523 PyObject* s1, *s2;
3524 s1 = wx2PyString(id);
3525 s2 = wx2PyString(client);
3526 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3527 Py_DECREF(so);
3528 Py_DECREF(s1);
3529 Py_DECREF(s2);
3530 if (ro) {
3531 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3532 rval = *ptr;
3533 Py_DECREF(ro);
3534 }
3535 }
3536 wxPyEndBlockThreads(blocked);
3537 return rval;
3538 }
3539
3540 PYPRIVATE;
3541 };
3542
3543 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3544
3545
3546
3547 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3548 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3549 PyObject* ret = PyTuple_New(3);
3550 if (ret) {
3551 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3552 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3553 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3554 }
3555 wxPyEndBlockThreads(blocked);
3556 return ret;
3557 }
3558
3559 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3560 bool cont;
3561 long index = 0;
3562 wxString value;
3563
3564 cont = self->GetFirstGroup(value, index);
3565 return __EnumerationHelper(cont, value, index);
3566 }
3567 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3568 bool cont;
3569 wxString value;
3570
3571 cont = self->GetNextGroup(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3575 bool cont;
3576 long index = 0;
3577 wxString value;
3578
3579 cont = self->GetFirstEntry(value, index);
3580 return __EnumerationHelper(cont, value, index);
3581 }
3582 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3583 bool cont;
3584 wxString value;
3585
3586 cont = self->GetNextEntry(value, index);
3587 return __EnumerationHelper(cont, value, index);
3588 }
3589 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3590 long rv;
3591 self->Read(key, &rv, defaultVal);
3592 return rv;
3593 }
3594
3595 SWIGINTERN int
3596 SWIG_AsVal_double (PyObject *obj, double* val)
3597 {
3598 if (PyNumber_Check(obj)) {
3599 if (val) *val = PyFloat_AsDouble(obj);
3600 return SWIG_OK;
3601 }
3602 return SWIG_TypeError;
3603 }
3604
3605 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3606 double rv;
3607 self->Read(key, &rv, defaultVal);
3608 return rv;
3609 }
3610
3611 #define SWIG_From_double PyFloat_FromDouble
3612
3613 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3614 bool rv;
3615 self->Read(key, &rv, defaultVal);
3616 return rv;
3617 }
3618
3619 #include <wx/datetime.h>
3620
3621 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3622 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3623
3624 #define LOCAL_TZ wxDateTime::Local
3625
3626 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3627 wxString am;
3628 wxString pm;
3629 wxDateTime::GetAmPmStrings(&am, &pm);
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* tup = PyTuple_New(2);
3632 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3633 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3634 wxPyEndBlockThreads(blocked);
3635 return tup;
3636 }
3637
3638 SWIGINTERNINLINE PyObject *
3639 SWIG_From_unsigned_SS_int (unsigned int value)
3640 {
3641 return SWIG_From_unsigned_SS_long (value);
3642 }
3643
3644 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3645 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3646 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3647 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3648 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3649 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3651 return (*self < *other);
3652 }
3653 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3655 return (*self <= *other);
3656 }
3657 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3659 return (*self > *other);
3660 }
3661 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3662 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3663 return (*self >= *other);
3664 }
3665 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3666 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3667 return (*self == *other);
3668 }
3669 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3670 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3671 return (*self != *other);
3672 }
3673 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3674 const wxChar* rv;
3675 const wxChar* _date = date;
3676 rv = self->ParseRfc822Date(_date);
3677 if (rv == NULL) return -1;
3678 return rv - _date;
3679 }
3680 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3681 const wxChar* rv;
3682 const wxChar* _date = date;
3683 rv = self->ParseFormat(_date, format, dateDef);
3684 if (rv == NULL) return -1;
3685 return rv - _date;
3686 }
3687 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3688 const wxChar* rv;
3689 const wxChar* _datetime = datetime;
3690 rv = self->ParseDateTime(_datetime);
3691 if (rv == NULL) return -1;
3692 return rv - _datetime;
3693 }
3694 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3695 const wxChar* rv;
3696 const wxChar* _date = date;
3697 rv = self->ParseDate(_date);
3698 if (rv == NULL) return -1;
3699 return rv - _date;
3700 }
3701 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3702 const wxChar* rv;
3703 const wxChar* _time = time;
3704 rv = self->ParseTime(_time);
3705 if (rv == NULL) return -1;
3706 return rv - _time;
3707 }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3712 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3713 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3714 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3715 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3716 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3717 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3718 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3719 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3720 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3721 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3722 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3723 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3724
3725 #include <wx/dataobj.h>
3726
3727 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3728 size_t count = self->GetFormatCount(dir);
3729 wxDataFormat* formats = new wxDataFormat[count];
3730 self->GetAllFormats(formats, dir);
3731
3732 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3733 PyObject* list = PyList_New(count);
3734 for (size_t i=0; i<count; i++) {
3735 wxDataFormat* format = new wxDataFormat(formats[i]);
3736 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3737 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3738 }
3739 wxPyEndBlockThreads(blocked);
3740 delete [] formats;
3741 return list;
3742 }
3743 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3744 PyObject* rval = NULL;
3745 size_t size = self->GetDataSize(format);
3746 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3747 if (size) {
3748 char* buf = new char[size];
3749 if (self->GetDataHere(format, buf))
3750 rval = PyString_FromStringAndSize(buf, size);
3751 delete [] buf;
3752 }
3753 if (! rval) {
3754 rval = Py_None;
3755 Py_INCREF(rval);
3756 }
3757 wxPyEndBlockThreads(blocked);
3758 return rval;
3759 }
3760 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3761 bool rval;
3762 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3763 if (PyString_Check(data)) {
3764 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3765 }
3766 else {
3767 // raise a TypeError if not a string
3768 PyErr_SetString(PyExc_TypeError, "String expected.");
3769 rval = false;
3770 }
3771 wxPyEndBlockThreads(blocked);
3772 return rval;
3773 }
3774 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3775 PyObject* rval = NULL;
3776 size_t size = self->GetDataSize();
3777 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3778 if (size) {
3779 char* buf = new char[size];
3780 if (self->GetDataHere(buf))
3781 rval = PyString_FromStringAndSize(buf, size);
3782 delete [] buf;
3783 }
3784 if (! rval) {
3785 rval = Py_None;
3786 Py_INCREF(rval);
3787 }
3788 wxPyEndBlockThreads(blocked);
3789 return rval;
3790 }
3791 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3792 bool rval;
3793 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3794 if (PyString_Check(data)) {
3795 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3796 }
3797 else {
3798 // raise a TypeError if not a string
3799 PyErr_SetString(PyExc_TypeError, "String expected.");
3800 rval = false;
3801 }
3802 wxPyEndBlockThreads(blocked);
3803 return rval;
3804 }
3805 // Create a new class for wxPython to use
3806 class wxPyDataObjectSimple : public wxDataObjectSimple {
3807 public:
3808 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3809 : wxDataObjectSimple(format) {}
3810
3811 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3812 bool GetDataHere(void *buf) const;
3813 bool SetData(size_t len, const void *buf);
3814 PYPRIVATE;
3815 };
3816
3817 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3818
3819 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3820 // We need to get the data for this object and write it to buf. I think
3821 // the best way to do this for wxPython is to have the Python method
3822 // return either a string or None and then act appropriately with the
3823 // C++ version.
3824
3825 bool rval = false;
3826 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3827 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3828 PyObject* ro;
3829 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3830 if (ro) {
3831 rval = (ro != Py_None && PyString_Check(ro));
3832 if (rval)
3833 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3834 Py_DECREF(ro);
3835 }
3836 }
3837 wxPyEndBlockThreads(blocked);
3838 return rval;
3839 }
3840
3841 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3842 // For this one we simply need to make a string from buf and len
3843 // and send it to the Python method.
3844 bool rval = false;
3845 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3846 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3847 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3848 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3849 Py_DECREF(data);
3850 }
3851 wxPyEndBlockThreads(blocked);
3852 return rval;
3853 }
3854
3855 // Create a new class for wxPython to use
3856 class wxPyTextDataObject : public wxTextDataObject {
3857 public:
3858 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3859 : wxTextDataObject(text) {}
3860
3861 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3862 DEC_PYCALLBACK_STRING__const(GetText);
3863 DEC_PYCALLBACK__STRING(SetText);
3864 PYPRIVATE;
3865 };
3866
3867 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3868 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3869 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3870
3871
3872 // Create a new class for wxPython to use
3873 class wxPyBitmapDataObject : public wxBitmapDataObject {
3874 public:
3875 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3876 : wxBitmapDataObject(bitmap) {}
3877
3878 wxBitmap GetBitmap() const;
3879 void SetBitmap(const wxBitmap& bitmap);
3880 PYPRIVATE;
3881 };
3882
3883 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3884 wxBitmap* rval = &wxNullBitmap;
3885 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3886 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3887 PyObject* ro;
3888 wxBitmap* ptr;
3889 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3890 if (ro) {
3891 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3892 rval = ptr;
3893 Py_DECREF(ro);
3894 }
3895 }
3896 wxPyEndBlockThreads(blocked);
3897 return *rval;
3898 }
3899
3900 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3901 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3902 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3903 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3904 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3905 Py_DECREF(bo);
3906 }
3907 wxPyEndBlockThreads(blocked);
3908 }
3909
3910 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3911 return new wxCustomDataObject(wxDataFormat(formatName));
3912 }
3913 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3914 bool rval;
3915 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3916 if (PyString_Check(data)) {
3917 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3918 }
3919 else {
3920 // raise a TypeError if not a string
3921 PyErr_SetString(PyExc_TypeError, "String expected.");
3922 rval = false;
3923 }
3924 wxPyEndBlockThreads(blocked);
3925 return rval;
3926 }
3927 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3928 PyObject* obj;
3929 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3930 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3931 wxPyEndBlockThreads(blocked);
3932 return obj;
3933 }
3934
3935 class wxMetafileDataObject : public wxDataObjectSimple
3936 {
3937 public:
3938 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3939 };
3940
3941
3942 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3943
3944
3945 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3946 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3947 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3948 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3949 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3950
3951
3952 class wxPyTextDropTarget : public wxTextDropTarget {
3953 public:
3954 wxPyTextDropTarget() {}
3955
3956 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3957
3958 DEC_PYCALLBACK__(OnLeave);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3960 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3961 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3962 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3963
3964 PYPRIVATE;
3965 };
3966
3967 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3968 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3970 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3971 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3972 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3973
3974
3975
3976 class wxPyFileDropTarget : public wxFileDropTarget {
3977 public:
3978 wxPyFileDropTarget() {}
3979
3980 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3981
3982 DEC_PYCALLBACK__(OnLeave);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3984 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3985 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3986 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3987
3988 PYPRIVATE;
3989 };
3990
3991 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3992 const wxArrayString& filenames) {
3993 bool rval = false;
3994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3995 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3996 PyObject* list = wxArrayString2PyList_helper(filenames);
3997 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3998 Py_DECREF(list);
3999 }
4000 wxPyEndBlockThreads(blocked);
4001 return rval;
4002 }
4003
4004
4005
4006 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4008 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4009 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4010 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4011
4012
4013
4014
4015 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4016
4017 #include <wx/display.h>
4018
4019 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4020 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4021
4022 #if !wxUSE_DISPLAY
4023 const wxVideoMode wxDefaultVideoMode;
4024 #endif
4025
4026 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4027 #if wxUSE_DISPLAY
4028 PyObject* pyList = NULL;
4029 wxArrayVideoModes arr = self->GetModes(mode);
4030 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4031 pyList = PyList_New(0);
4032 for (size_t i=0; i < arr.GetCount(); i++)
4033 {
4034 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4035 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4036 PyList_Append(pyList, pyObj);
4037 Py_DECREF(pyObj);
4038 }
4039 wxPyEndBlockThreads(blocked);
4040 return pyList;
4041 #else
4042 wxPyRaiseNotImplemented();
4043 return NULL;
4044 #endif
4045 }
4046 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4047 #if wxUSE_DISPLAY
4048 return self->GetCurrentMode();
4049 #else
4050 wxPyRaiseNotImplemented();
4051 return wxDefaultVideoMode;
4052 #endif
4053 }
4054 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4055 #if wxUSE_DISPLAY
4056 return self->ChangeMode(mode);
4057 #else
4058 wxPyRaiseNotImplemented();
4059 return false;
4060 #endif
4061 }
4062 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4063 #if wxUSE_DISPLAY
4064 self->ResetMode();
4065 #else
4066 wxPyRaiseNotImplemented();
4067 #endif
4068 }
4069
4070 #include <wx/stdpaths.h>
4071
4072 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4073 return (wxStandardPaths*) &wxStandardPaths::Get();
4074 }
4075
4076 #ifndef wxHAS_POWER_EVENTS
4077 // Dummy class and other definitions for platforms that don't have them
4078
4079 // See wxPython_int.h for wxPowerEvent
4080
4081 enum {
4082 wxEVT_POWER_SUSPENDING,
4083 wxEVT_POWER_SUSPENDED,
4084 wxEVT_POWER_SUSPEND_CANCEL,
4085 wxEVT_POWER_RESUME,
4086 };
4087
4088 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4089 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4090
4091 #endif
4092
4093
4094 #include <wx/aboutdlg.h>
4095
4096 #ifdef __cplusplus
4097 extern "C" {
4098 #endif
4099 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj = 0;
4101 wxSystemColour arg1 ;
4102 wxColour result;
4103 int val1 ;
4104 int ecode1 = 0 ;
4105 PyObject * obj0 = 0 ;
4106 char * kwnames[] = {
4107 (char *) "index", NULL
4108 };
4109
4110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4111 ecode1 = SWIG_AsVal_int(obj0, &val1);
4112 if (!SWIG_IsOK(ecode1)) {
4113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4114 }
4115 arg1 = static_cast< wxSystemColour >(val1);
4116 {
4117 if (!wxPyCheckForApp()) SWIG_fail;
4118 PyThreadState* __tstate = wxPyBeginAllowThreads();
4119 result = wxSystemSettings::GetColour(arg1);
4120 wxPyEndAllowThreads(__tstate);
4121 if (PyErr_Occurred()) SWIG_fail;
4122 }
4123 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4124 return resultobj;
4125 fail:
4126 return NULL;
4127 }
4128
4129
4130 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4131 PyObject *resultobj = 0;
4132 wxSystemFont arg1 ;
4133 wxFont result;
4134 int val1 ;
4135 int ecode1 = 0 ;
4136 PyObject * obj0 = 0 ;
4137 char * kwnames[] = {
4138 (char *) "index", NULL
4139 };
4140
4141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4142 ecode1 = SWIG_AsVal_int(obj0, &val1);
4143 if (!SWIG_IsOK(ecode1)) {
4144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4145 }
4146 arg1 = static_cast< wxSystemFont >(val1);
4147 {
4148 if (!wxPyCheckForApp()) SWIG_fail;
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 result = wxSystemSettings::GetFont(arg1);
4151 wxPyEndAllowThreads(__tstate);
4152 if (PyErr_Occurred()) SWIG_fail;
4153 }
4154 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4155 return resultobj;
4156 fail:
4157 return NULL;
4158 }
4159
4160
4161 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4162 PyObject *resultobj = 0;
4163 wxSystemMetric arg1 ;
4164 wxWindow *arg2 = (wxWindow *) NULL ;
4165 int result;
4166 int val1 ;
4167 int ecode1 = 0 ;
4168 void *argp2 = 0 ;
4169 int res2 = 0 ;
4170 PyObject * obj0 = 0 ;
4171 PyObject * obj1 = 0 ;
4172 char * kwnames[] = {
4173 (char *) "index",(char *) "win", NULL
4174 };
4175
4176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4177 ecode1 = SWIG_AsVal_int(obj0, &val1);
4178 if (!SWIG_IsOK(ecode1)) {
4179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4180 }
4181 arg1 = static_cast< wxSystemMetric >(val1);
4182 if (obj1) {
4183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4184 if (!SWIG_IsOK(res2)) {
4185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4186 }
4187 arg2 = reinterpret_cast< wxWindow * >(argp2);
4188 }
4189 {
4190 if (!wxPyCheckForApp()) SWIG_fail;
4191 PyThreadState* __tstate = wxPyBeginAllowThreads();
4192 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4193 wxPyEndAllowThreads(__tstate);
4194 if (PyErr_Occurred()) SWIG_fail;
4195 }
4196 resultobj = SWIG_From_int(static_cast< int >(result));
4197 return resultobj;
4198 fail:
4199 return NULL;
4200 }
4201
4202
4203 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4204 PyObject *resultobj = 0;
4205 wxSystemFeature arg1 ;
4206 bool result;
4207 int val1 ;
4208 int ecode1 = 0 ;
4209 PyObject * obj0 = 0 ;
4210 char * kwnames[] = {
4211 (char *) "index", NULL
4212 };
4213
4214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4215 ecode1 = SWIG_AsVal_int(obj0, &val1);
4216 if (!SWIG_IsOK(ecode1)) {
4217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4218 }
4219 arg1 = static_cast< wxSystemFeature >(val1);
4220 {
4221 if (!wxPyCheckForApp()) SWIG_fail;
4222 PyThreadState* __tstate = wxPyBeginAllowThreads();
4223 result = (bool)wxSystemSettings::HasFeature(arg1);
4224 wxPyEndAllowThreads(__tstate);
4225 if (PyErr_Occurred()) SWIG_fail;
4226 }
4227 {
4228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4229 }
4230 return resultobj;
4231 fail:
4232 return NULL;
4233 }
4234
4235
4236 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4237 PyObject *resultobj = 0;
4238 wxSystemScreenType result;
4239
4240 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4241 {
4242 if (!wxPyCheckForApp()) SWIG_fail;
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4245 wxPyEndAllowThreads(__tstate);
4246 if (PyErr_Occurred()) SWIG_fail;
4247 }
4248 resultobj = SWIG_From_int(static_cast< int >(result));
4249 return resultobj;
4250 fail:
4251 return NULL;
4252 }
4253
4254
4255 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4256 PyObject *resultobj = 0;
4257 wxSystemScreenType arg1 ;
4258 int val1 ;
4259 int ecode1 = 0 ;
4260 PyObject * obj0 = 0 ;
4261 char * kwnames[] = {
4262 (char *) "screen", NULL
4263 };
4264
4265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4266 ecode1 = SWIG_AsVal_int(obj0, &val1);
4267 if (!SWIG_IsOK(ecode1)) {
4268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4269 }
4270 arg1 = static_cast< wxSystemScreenType >(val1);
4271 {
4272 if (!wxPyCheckForApp()) SWIG_fail;
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 wxSystemSettings::SetScreenType(arg1);
4275 wxPyEndAllowThreads(__tstate);
4276 if (PyErr_Occurred()) SWIG_fail;
4277 }
4278 resultobj = SWIG_Py_Void();
4279 return resultobj;
4280 fail:
4281 return NULL;
4282 }
4283
4284
4285 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4286 PyObject *obj;
4287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4288 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4289 return SWIG_Py_Void();
4290 }
4291
4292 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4293 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4294 return 1;
4295 }
4296
4297
4298 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4299 PyObject *pyobj = 0;
4300
4301 {
4302 #if wxUSE_UNICODE
4303 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4304 #else
4305 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4306 #endif
4307 }
4308 return pyobj;
4309 }
4310
4311
4312 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4313 PyObject *resultobj = 0;
4314 wxSystemOptions *result = 0 ;
4315
4316 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = (wxSystemOptions *)new wxSystemOptions();
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4331 PyObject *resultobj = 0;
4332 wxString *arg1 = 0 ;
4333 wxString *arg2 = 0 ;
4334 bool temp1 = false ;
4335 bool temp2 = false ;
4336 PyObject * obj0 = 0 ;
4337 PyObject * obj1 = 0 ;
4338 char * kwnames[] = {
4339 (char *) "name",(char *) "value", NULL
4340 };
4341
4342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4343 {
4344 arg1 = wxString_in_helper(obj0);
4345 if (arg1 == NULL) SWIG_fail;
4346 temp1 = true;
4347 }
4348 {
4349 arg2 = wxString_in_helper(obj1);
4350 if (arg2 == NULL) SWIG_fail;
4351 temp2 = true;
4352 }
4353 {
4354 PyThreadState* __tstate = wxPyBeginAllowThreads();
4355 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4356 wxPyEndAllowThreads(__tstate);
4357 if (PyErr_Occurred()) SWIG_fail;
4358 }
4359 resultobj = SWIG_Py_Void();
4360 {
4361 if (temp1)
4362 delete arg1;
4363 }
4364 {
4365 if (temp2)
4366 delete arg2;
4367 }
4368 return resultobj;
4369 fail:
4370 {
4371 if (temp1)
4372 delete arg1;
4373 }
4374 {
4375 if (temp2)
4376 delete arg2;
4377 }
4378 return NULL;
4379 }
4380
4381
4382 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4383 PyObject *resultobj = 0;
4384 wxString *arg1 = 0 ;
4385 int arg2 ;
4386 bool temp1 = false ;
4387 int val2 ;
4388 int ecode2 = 0 ;
4389 PyObject * obj0 = 0 ;
4390 PyObject * obj1 = 0 ;
4391 char * kwnames[] = {
4392 (char *) "name",(char *) "value", NULL
4393 };
4394
4395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4396 {
4397 arg1 = wxString_in_helper(obj0);
4398 if (arg1 == NULL) SWIG_fail;
4399 temp1 = true;
4400 }
4401 ecode2 = SWIG_AsVal_int(obj1, &val2);
4402 if (!SWIG_IsOK(ecode2)) {
4403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4404 }
4405 arg2 = static_cast< int >(val2);
4406 {
4407 PyThreadState* __tstate = wxPyBeginAllowThreads();
4408 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4409 wxPyEndAllowThreads(__tstate);
4410 if (PyErr_Occurred()) SWIG_fail;
4411 }
4412 resultobj = SWIG_Py_Void();
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return resultobj;
4418 fail:
4419 {
4420 if (temp1)
4421 delete arg1;
4422 }
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = 0;
4429 wxString *arg1 = 0 ;
4430 wxString result;
4431 bool temp1 = false ;
4432 PyObject * obj0 = 0 ;
4433 char * kwnames[] = {
4434 (char *) "name", NULL
4435 };
4436
4437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4438 {
4439 arg1 = wxString_in_helper(obj0);
4440 if (arg1 == NULL) SWIG_fail;
4441 temp1 = true;
4442 }
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4446 wxPyEndAllowThreads(__tstate);
4447 if (PyErr_Occurred()) SWIG_fail;
4448 }
4449 {
4450 #if wxUSE_UNICODE
4451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4452 #else
4453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4454 #endif
4455 }
4456 {
4457 if (temp1)
4458 delete arg1;
4459 }
4460 return resultobj;
4461 fail:
4462 {
4463 if (temp1)
4464 delete arg1;
4465 }
4466 return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj = 0;
4472 wxString *arg1 = 0 ;
4473 int result;
4474 bool temp1 = false ;
4475 PyObject * obj0 = 0 ;
4476 char * kwnames[] = {
4477 (char *) "name", NULL
4478 };
4479
4480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4481 {
4482 arg1 = wxString_in_helper(obj0);
4483 if (arg1 == NULL) SWIG_fail;
4484 temp1 = true;
4485 }
4486 {
4487 PyThreadState* __tstate = wxPyBeginAllowThreads();
4488 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4489 wxPyEndAllowThreads(__tstate);
4490 if (PyErr_Occurred()) SWIG_fail;
4491 }
4492 resultobj = SWIG_From_int(static_cast< int >(result));
4493 {
4494 if (temp1)
4495 delete arg1;
4496 }
4497 return resultobj;
4498 fail:
4499 {
4500 if (temp1)
4501 delete arg1;
4502 }
4503 return NULL;
4504 }
4505
4506
4507 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj = 0;
4509 wxString *arg1 = 0 ;
4510 bool result;
4511 bool temp1 = false ;
4512 PyObject * obj0 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "name", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4518 {
4519 arg1 = wxString_in_helper(obj0);
4520 if (arg1 == NULL) SWIG_fail;
4521 temp1 = true;
4522 }
4523 {
4524 PyThreadState* __tstate = wxPyBeginAllowThreads();
4525 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4526 wxPyEndAllowThreads(__tstate);
4527 if (PyErr_Occurred()) SWIG_fail;
4528 }
4529 {
4530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4531 }
4532 {
4533 if (temp1)
4534 delete arg1;
4535 }
4536 return resultobj;
4537 fail:
4538 {
4539 if (temp1)
4540 delete arg1;
4541 }
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4547 PyObject *resultobj = 0;
4548 wxString *arg1 = 0 ;
4549 bool result;
4550 bool temp1 = false ;
4551 PyObject * obj0 = 0 ;
4552 char * kwnames[] = {
4553 (char *) "name", NULL
4554 };
4555
4556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4557 {
4558 arg1 = wxString_in_helper(obj0);
4559 if (arg1 == NULL) SWIG_fail;
4560 temp1 = true;
4561 }
4562 {
4563 PyThreadState* __tstate = wxPyBeginAllowThreads();
4564 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4565 wxPyEndAllowThreads(__tstate);
4566 if (PyErr_Occurred()) SWIG_fail;
4567 }
4568 {
4569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4570 }
4571 {
4572 if (temp1)
4573 delete arg1;
4574 }
4575 return resultobj;
4576 fail:
4577 {
4578 if (temp1)
4579 delete arg1;
4580 }
4581 return NULL;
4582 }
4583
4584
4585 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4586 PyObject *obj;
4587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4588 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4589 return SWIG_Py_Void();
4590 }
4591
4592 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4593 return SWIG_Python_InitShadowInstance(args);
4594 }
4595
4596 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4597 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4598 return 1;
4599 }
4600
4601
4602 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4603 PyObject *pyobj = 0;
4604
4605 {
4606 #if wxUSE_UNICODE
4607 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4608 #else
4609 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4610 #endif
4611 }
4612 return pyobj;
4613 }
4614
4615
4616 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4617 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4618 return 1;
4619 }
4620
4621
4622 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4623 PyObject *pyobj = 0;
4624
4625 {
4626 #if wxUSE_UNICODE
4627 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4628 #else
4629 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4630 #endif
4631 }
4632 return pyobj;
4633 }
4634
4635
4636 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4637 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4638 return 1;
4639 }
4640
4641
4642 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4643 PyObject *pyobj = 0;
4644
4645 {
4646 #if wxUSE_UNICODE
4647 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4648 #else
4649 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4650 #endif
4651 }
4652 return pyobj;
4653 }
4654
4655
4656 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4657 PyObject *resultobj = 0;
4658 long result;
4659
4660 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 result = (long)wxNewId();
4664 wxPyEndAllowThreads(__tstate);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 resultobj = SWIG_From_long(static_cast< long >(result));
4668 return resultobj;
4669 fail:
4670 return NULL;
4671 }
4672
4673
4674 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4675 PyObject *resultobj = 0;
4676 long arg1 ;
4677 long val1 ;
4678 int ecode1 = 0 ;
4679 PyObject * obj0 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "id", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4685 ecode1 = SWIG_AsVal_long(obj0, &val1);
4686 if (!SWIG_IsOK(ecode1)) {
4687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4688 }
4689 arg1 = static_cast< long >(val1);
4690 {
4691 PyThreadState* __tstate = wxPyBeginAllowThreads();
4692 wxRegisterId(arg1);
4693 wxPyEndAllowThreads(__tstate);
4694 if (PyErr_Occurred()) SWIG_fail;
4695 }
4696 resultobj = SWIG_Py_Void();
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4704 PyObject *resultobj = 0;
4705 long result;
4706
4707 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = (long)wxGetCurrentId();
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 resultobj = SWIG_From_long(static_cast< long >(result));
4715 return resultobj;
4716 fail:
4717 return NULL;
4718 }
4719
4720
4721 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4722 PyObject *resultobj = 0;
4723 int arg1 ;
4724 bool result;
4725 int val1 ;
4726 int ecode1 = 0 ;
4727 PyObject * obj0 = 0 ;
4728 char * kwnames[] = {
4729 (char *) "id", NULL
4730 };
4731
4732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4733 ecode1 = SWIG_AsVal_int(obj0, &val1);
4734 if (!SWIG_IsOK(ecode1)) {
4735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4736 }
4737 arg1 = static_cast< int >(val1);
4738 {
4739 PyThreadState* __tstate = wxPyBeginAllowThreads();
4740 result = (bool)wxIsStockID(arg1);
4741 wxPyEndAllowThreads(__tstate);
4742 if (PyErr_Occurred()) SWIG_fail;
4743 }
4744 {
4745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4746 }
4747 return resultobj;
4748 fail:
4749 return NULL;
4750 }
4751
4752
4753 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4754 PyObject *resultobj = 0;
4755 int arg1 ;
4756 wxString *arg2 = 0 ;
4757 bool result;
4758 int val1 ;
4759 int ecode1 = 0 ;
4760 bool temp2 = false ;
4761 PyObject * obj0 = 0 ;
4762 PyObject * obj1 = 0 ;
4763 char * kwnames[] = {
4764 (char *) "id",(char *) "label", NULL
4765 };
4766
4767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4768 ecode1 = SWIG_AsVal_int(obj0, &val1);
4769 if (!SWIG_IsOK(ecode1)) {
4770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4771 }
4772 arg1 = static_cast< int >(val1);
4773 {
4774 arg2 = wxString_in_helper(obj1);
4775 if (arg2 == NULL) SWIG_fail;
4776 temp2 = true;
4777 }
4778 {
4779 PyThreadState* __tstate = wxPyBeginAllowThreads();
4780 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4781 wxPyEndAllowThreads(__tstate);
4782 if (PyErr_Occurred()) SWIG_fail;
4783 }
4784 {
4785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4786 }
4787 {
4788 if (temp2)
4789 delete arg2;
4790 }
4791 return resultobj;
4792 fail:
4793 {
4794 if (temp2)
4795 delete arg2;
4796 }
4797 return NULL;
4798 }
4799
4800
4801 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4802 PyObject *resultobj = 0;
4803 int arg1 ;
4804 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4805 wxString result;
4806 int val1 ;
4807 int ecode1 = 0 ;
4808 long val2 ;
4809 int ecode2 = 0 ;
4810 PyObject * obj0 = 0 ;
4811 PyObject * obj1 = 0 ;
4812 char * kwnames[] = {
4813 (char *) "id",(char *) "flags", NULL
4814 };
4815
4816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4817 ecode1 = SWIG_AsVal_int(obj0, &val1);
4818 if (!SWIG_IsOK(ecode1)) {
4819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4820 }
4821 arg1 = static_cast< int >(val1);
4822 if (obj1) {
4823 ecode2 = SWIG_AsVal_long(obj1, &val2);
4824 if (!SWIG_IsOK(ecode2)) {
4825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4826 }
4827 arg2 = static_cast< long >(val2);
4828 }
4829 {
4830 PyThreadState* __tstate = wxPyBeginAllowThreads();
4831 result = wxGetStockLabel(arg1,arg2);
4832 wxPyEndAllowThreads(__tstate);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 {
4836 #if wxUSE_UNICODE
4837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4838 #else
4839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4840 #endif
4841 }
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 int arg1 ;
4851 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4852 wxString result;
4853 int val1 ;
4854 int ecode1 = 0 ;
4855 int val2 ;
4856 int ecode2 = 0 ;
4857 PyObject * obj0 = 0 ;
4858 PyObject * obj1 = 0 ;
4859 char * kwnames[] = {
4860 (char *) "id",(char *) "client", NULL
4861 };
4862
4863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4864 ecode1 = SWIG_AsVal_int(obj0, &val1);
4865 if (!SWIG_IsOK(ecode1)) {
4866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4867 }
4868 arg1 = static_cast< int >(val1);
4869 if (obj1) {
4870 ecode2 = SWIG_AsVal_int(obj1, &val2);
4871 if (!SWIG_IsOK(ecode2)) {
4872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4873 }
4874 arg2 = static_cast< wxStockHelpStringClient >(val2);
4875 }
4876 {
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 result = wxGetStockHelpString(arg1,arg2);
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 {
4883 #if wxUSE_UNICODE
4884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4885 #else
4886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4887 #endif
4888 }
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4896 PyObject *resultobj = 0;
4897
4898 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4899 {
4900 if (!wxPyCheckForApp()) SWIG_fail;
4901 PyThreadState* __tstate = wxPyBeginAllowThreads();
4902 wxBell();
4903 wxPyEndAllowThreads(__tstate);
4904 if (PyErr_Occurred()) SWIG_fail;
4905 }
4906 resultobj = SWIG_Py_Void();
4907 return resultobj;
4908 fail:
4909 return NULL;
4910 }
4911
4912
4913 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4914 PyObject *resultobj = 0;
4915
4916 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4917 {
4918 if (!wxPyCheckForApp()) SWIG_fail;
4919 PyThreadState* __tstate = wxPyBeginAllowThreads();
4920 wxEndBusyCursor();
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 resultobj = SWIG_Py_Void();
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 bool arg1 = (bool) true ;
4934 long result;
4935 bool val1 ;
4936 int ecode1 = 0 ;
4937 PyObject * obj0 = 0 ;
4938 char * kwnames[] = {
4939 (char *) "resetTimer", NULL
4940 };
4941
4942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4943 if (obj0) {
4944 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4945 if (!SWIG_IsOK(ecode1)) {
4946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4947 }
4948 arg1 = static_cast< bool >(val1);
4949 }
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 result = (long)wxGetElapsedTime(arg1);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_From_long(static_cast< long >(result));
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4964 PyObject *resultobj = 0;
4965 bool result;
4966
4967 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 result = (bool)wxIsBusy();
4971 wxPyEndAllowThreads(__tstate);
4972 if (PyErr_Occurred()) SWIG_fail;
4973 }
4974 {
4975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4976 }
4977 return resultobj;
4978 fail:
4979 return NULL;
4980 }
4981
4982
4983 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4984 PyObject *resultobj = 0;
4985 wxString result;
4986
4987 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 result = wxNow();
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 {
4995 #if wxUSE_UNICODE
4996 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4997 #else
4998 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4999 #endif
5000 }
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
5007 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5008 PyObject *resultobj = 0;
5009 wxString const &arg1_defvalue = wxPyEmptyString ;
5010 wxString *arg1 = (wxString *) &arg1_defvalue ;
5011 bool result;
5012 bool temp1 = false ;
5013 PyObject * obj0 = 0 ;
5014 char * kwnames[] = {
5015 (char *) "command", NULL
5016 };
5017
5018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5019 if (obj0) {
5020 {
5021 arg1 = wxString_in_helper(obj0);
5022 if (arg1 == NULL) SWIG_fail;
5023 temp1 = true;
5024 }
5025 }
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 result = (bool)wxShell((wxString const &)*arg1);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5034 }
5035 {
5036 if (temp1)
5037 delete arg1;
5038 }
5039 return resultobj;
5040 fail:
5041 {
5042 if (temp1)
5043 delete arg1;
5044 }
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5050 PyObject *resultobj = 0;
5051
5052 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5053 {
5054 PyThreadState* __tstate = wxPyBeginAllowThreads();
5055 wxStartTimer();
5056 wxPyEndAllowThreads(__tstate);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 resultobj = SWIG_Py_Void();
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5067 PyObject *resultobj = 0;
5068 int *arg1 = (int *) 0 ;
5069 int *arg2 = (int *) 0 ;
5070 int result;
5071 int temp1 ;
5072 int res1 = SWIG_TMPOBJ ;
5073 int temp2 ;
5074 int res2 = SWIG_TMPOBJ ;
5075
5076 arg1 = &temp1;
5077 arg2 = &temp2;
5078 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5079 {
5080 PyThreadState* __tstate = wxPyBeginAllowThreads();
5081 result = (int)wxGetOsVersion(arg1,arg2);
5082 wxPyEndAllowThreads(__tstate);
5083 if (PyErr_Occurred()) SWIG_fail;
5084 }
5085 resultobj = SWIG_From_int(static_cast< int >(result));
5086 if (SWIG_IsTmpObj(res1)) {
5087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5088 } else {
5089 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5091 }
5092 if (SWIG_IsTmpObj(res2)) {
5093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5094 } else {
5095 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5097 }
5098 return resultobj;
5099 fail:
5100 return NULL;
5101 }
5102
5103
5104 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5105 PyObject *resultobj = 0;
5106 wxString result;
5107
5108 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = wxGetOsDescription();
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 {
5116 #if wxUSE_UNICODE
5117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5118 #else
5119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5120 #endif
5121 }
5122 return resultobj;
5123 fail:
5124 return NULL;
5125 }
5126
5127
5128 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5129 PyObject *resultobj = 0;
5130 bool result;
5131
5132 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 result = (bool)wxIsPlatformLittleEndian();
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 {
5140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5141 }
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 bool result;
5151
5152 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 result = (bool)wxIsPlatform64Bit();
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 {
5160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5161 }
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
5168 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5169 PyObject *resultobj = 0;
5170 wxMemorySize result;
5171
5172 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5173 {
5174 PyThreadState* __tstate = wxPyBeginAllowThreads();
5175 result = wxGetFreeMemory();
5176 wxPyEndAllowThreads(__tstate);
5177 if (PyErr_Occurred()) SWIG_fail;
5178 }
5179 {
5180 #if wxUSE_LONGLONG
5181 resultobj = PyLong_FromLongLong((&result)->GetValue());
5182 #else
5183 resultobj = PyInt_FromLong(result);
5184 #endif
5185 }
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj = 0;
5194 wxShutdownFlags arg1 ;
5195 bool result;
5196 int val1 ;
5197 int ecode1 = 0 ;
5198 PyObject * obj0 = 0 ;
5199 char * kwnames[] = {
5200 (char *) "wFlags", NULL
5201 };
5202
5203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5204 ecode1 = SWIG_AsVal_int(obj0, &val1);
5205 if (!SWIG_IsOK(ecode1)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5207 }
5208 arg1 = static_cast< wxShutdownFlags >(val1);
5209 {
5210 if (!wxPyCheckForApp()) SWIG_fail;
5211 PyThreadState* __tstate = wxPyBeginAllowThreads();
5212 result = (bool)wxShutdown(arg1);
5213 wxPyEndAllowThreads(__tstate);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 {
5217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5218 }
5219 return resultobj;
5220 fail:
5221 return NULL;
5222 }
5223
5224
5225 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5226 PyObject *resultobj = 0;
5227 int arg1 ;
5228 int val1 ;
5229 int ecode1 = 0 ;
5230 PyObject * obj0 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "secs", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5236 ecode1 = SWIG_AsVal_int(obj0, &val1);
5237 if (!SWIG_IsOK(ecode1)) {
5238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5239 }
5240 arg1 = static_cast< int >(val1);
5241 {
5242 PyThreadState* __tstate = wxPyBeginAllowThreads();
5243 wxSleep(arg1);
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 resultobj = SWIG_Py_Void();
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj = 0;
5256 unsigned long arg1 ;
5257 unsigned long val1 ;
5258 int ecode1 = 0 ;
5259 PyObject * obj0 = 0 ;
5260 char * kwnames[] = {
5261 (char *) "milliseconds", NULL
5262 };
5263
5264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5265 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5266 if (!SWIG_IsOK(ecode1)) {
5267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5268 }
5269 arg1 = static_cast< unsigned long >(val1);
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 wxMilliSleep(arg1);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj = 0;
5285 unsigned long arg1 ;
5286 unsigned long val1 ;
5287 int ecode1 = 0 ;
5288 PyObject * obj0 = 0 ;
5289 char * kwnames[] = {
5290 (char *) "microseconds", NULL
5291 };
5292
5293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5294 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5295 if (!SWIG_IsOK(ecode1)) {
5296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5297 }
5298 arg1 = static_cast< unsigned long >(val1);
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 wxMicroSleep(arg1);
5302 wxPyEndAllowThreads(__tstate);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5313 PyObject *resultobj = 0;
5314 bool arg1 ;
5315 bool val1 ;
5316 int ecode1 = 0 ;
5317 PyObject * obj0 = 0 ;
5318 char * kwnames[] = {
5319 (char *) "enable", NULL
5320 };
5321
5322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5323 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5324 if (!SWIG_IsOK(ecode1)) {
5325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5326 }
5327 arg1 = static_cast< bool >(val1);
5328 {
5329 PyThreadState* __tstate = wxPyBeginAllowThreads();
5330 wxEnableTopLevelWindows(arg1);
5331 wxPyEndAllowThreads(__tstate);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 resultobj = SWIG_Py_Void();
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5342 PyObject *resultobj = 0;
5343 wxString *arg1 = 0 ;
5344 wxString result;
5345 bool temp1 = false ;
5346 PyObject * obj0 = 0 ;
5347 char * kwnames[] = {
5348 (char *) "in", NULL
5349 };
5350
5351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5352 {
5353 arg1 = wxString_in_helper(obj0);
5354 if (arg1 == NULL) SWIG_fail;
5355 temp1 = true;
5356 }
5357 {
5358 PyThreadState* __tstate = wxPyBeginAllowThreads();
5359 result = wxStripMenuCodes((wxString const &)*arg1);
5360 wxPyEndAllowThreads(__tstate);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 #if wxUSE_UNICODE
5365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5366 #else
5367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5368 #endif
5369 }
5370 {
5371 if (temp1)
5372 delete arg1;
5373 }
5374 return resultobj;
5375 fail:
5376 {
5377 if (temp1)
5378 delete arg1;
5379 }
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxString result;
5387
5388 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = wxGetEmailAddress();
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_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5409 PyObject *resultobj = 0;
5410 wxString result;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5413 {
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 result = wxGetHostName();
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_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxString result;
5435
5436 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = wxGetFullHostName();
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 {
5444 #if wxUSE_UNICODE
5445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5446 #else
5447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5448 #endif
5449 }
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5457 PyObject *resultobj = 0;
5458 wxString result;
5459
5460 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5461 {
5462 PyThreadState* __tstate = wxPyBeginAllowThreads();
5463 result = wxGetUserId();
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 {
5468 #if wxUSE_UNICODE
5469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5470 #else
5471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5472 #endif
5473 }
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482 wxString result;
5483
5484 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = wxGetUserName();
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 #if wxUSE_UNICODE
5493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5494 #else
5495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5496 #endif
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506 wxString result;
5507
5508 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5509 {
5510 PyThreadState* __tstate = wxPyBeginAllowThreads();
5511 result = wxGetHomeDir();
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 #if wxUSE_UNICODE
5517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5518 #else
5519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5520 #endif
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj = 0;
5530 wxString const &arg1_defvalue = wxPyEmptyString ;
5531 wxString *arg1 = (wxString *) &arg1_defvalue ;
5532 wxString result;
5533 bool temp1 = false ;
5534 PyObject * obj0 = 0 ;
5535 char * kwnames[] = {
5536 (char *) "user", NULL
5537 };
5538
5539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5540 if (obj0) {
5541 {
5542 arg1 = wxString_in_helper(obj0);
5543 if (arg1 == NULL) SWIG_fail;
5544 temp1 = true;
5545 }
5546 }
5547 {
5548 PyThreadState* __tstate = wxPyBeginAllowThreads();
5549 result = wxGetUserHome((wxString const &)*arg1);
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 #if wxUSE_UNICODE
5555 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5556 #else
5557 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5558 #endif
5559 }
5560 {
5561 if (temp1)
5562 delete arg1;
5563 }
5564 return resultobj;
5565 fail:
5566 {
5567 if (temp1)
5568 delete arg1;
5569 }
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575 PyObject *resultobj = 0;
5576 unsigned long result;
5577
5578 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (unsigned long)wxGetProcessId();
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *resultobj = 0;
5594
5595 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5596 {
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 wxTrap();
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 resultobj = SWIG_Py_Void();
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj = 0;
5611 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5612 wxString *arg1 = (wxString *) &arg1_defvalue ;
5613 wxString const &arg2_defvalue = wxPyEmptyString ;
5614 wxString *arg2 = (wxString *) &arg2_defvalue ;
5615 wxString const &arg3_defvalue = wxPyEmptyString ;
5616 wxString *arg3 = (wxString *) &arg3_defvalue ;
5617 wxString const &arg4_defvalue = wxPyEmptyString ;
5618 wxString *arg4 = (wxString *) &arg4_defvalue ;
5619 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5620 wxString *arg5 = (wxString *) &arg5_defvalue ;
5621 int arg6 = (int) 0 ;
5622 wxWindow *arg7 = (wxWindow *) NULL ;
5623 int arg8 = (int) -1 ;
5624 int arg9 = (int) -1 ;
5625 wxString result;
5626 bool temp1 = false ;
5627 bool temp2 = false ;
5628 bool temp3 = false ;
5629 bool temp4 = false ;
5630 bool temp5 = false ;
5631 int val6 ;
5632 int ecode6 = 0 ;
5633 void *argp7 = 0 ;
5634 int res7 = 0 ;
5635 int val8 ;
5636 int ecode8 = 0 ;
5637 int val9 ;
5638 int ecode9 = 0 ;
5639 PyObject * obj0 = 0 ;
5640 PyObject * obj1 = 0 ;
5641 PyObject * obj2 = 0 ;
5642 PyObject * obj3 = 0 ;
5643 PyObject * obj4 = 0 ;
5644 PyObject * obj5 = 0 ;
5645 PyObject * obj6 = 0 ;
5646 PyObject * obj7 = 0 ;
5647 PyObject * obj8 = 0 ;
5648 char * kwnames[] = {
5649 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5650 };
5651
5652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5653 if (obj0) {
5654 {
5655 arg1 = wxString_in_helper(obj0);
5656 if (arg1 == NULL) SWIG_fail;
5657 temp1 = true;
5658 }
5659 }
5660 if (obj1) {
5661 {
5662 arg2 = wxString_in_helper(obj1);
5663 if (arg2 == NULL) SWIG_fail;
5664 temp2 = true;
5665 }
5666 }
5667 if (obj2) {
5668 {
5669 arg3 = wxString_in_helper(obj2);
5670 if (arg3 == NULL) SWIG_fail;
5671 temp3 = true;
5672 }
5673 }
5674 if (obj3) {
5675 {
5676 arg4 = wxString_in_helper(obj3);
5677 if (arg4 == NULL) SWIG_fail;
5678 temp4 = true;
5679 }
5680 }
5681 if (obj4) {
5682 {
5683 arg5 = wxString_in_helper(obj4);
5684 if (arg5 == NULL) SWIG_fail;
5685 temp5 = true;
5686 }
5687 }
5688 if (obj5) {
5689 ecode6 = SWIG_AsVal_int(obj5, &val6);
5690 if (!SWIG_IsOK(ecode6)) {
5691 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5692 }
5693 arg6 = static_cast< int >(val6);
5694 }
5695 if (obj6) {
5696 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5697 if (!SWIG_IsOK(res7)) {
5698 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5699 }
5700 arg7 = reinterpret_cast< wxWindow * >(argp7);
5701 }
5702 if (obj7) {
5703 ecode8 = SWIG_AsVal_int(obj7, &val8);
5704 if (!SWIG_IsOK(ecode8)) {
5705 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5706 }
5707 arg8 = static_cast< int >(val8);
5708 }
5709 if (obj8) {
5710 ecode9 = SWIG_AsVal_int(obj8, &val9);
5711 if (!SWIG_IsOK(ecode9)) {
5712 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5713 }
5714 arg9 = static_cast< int >(val9);
5715 }
5716 {
5717 if (!wxPyCheckForApp()) SWIG_fail;
5718 PyThreadState* __tstate = wxPyBeginAllowThreads();
5719 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5720 wxPyEndAllowThreads(__tstate);
5721 if (PyErr_Occurred()) SWIG_fail;
5722 }
5723 {
5724 #if wxUSE_UNICODE
5725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5726 #else
5727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5728 #endif
5729 }
5730 {
5731 if (temp1)
5732 delete arg1;
5733 }
5734 {
5735 if (temp2)
5736 delete arg2;
5737 }
5738 {
5739 if (temp3)
5740 delete arg3;
5741 }
5742 {
5743 if (temp4)
5744 delete arg4;
5745 }
5746 {
5747 if (temp5)
5748 delete arg5;
5749 }
5750 return resultobj;
5751 fail:
5752 {
5753 if (temp1)
5754 delete arg1;
5755 }
5756 {
5757 if (temp2)
5758 delete arg2;
5759 }
5760 {
5761 if (temp3)
5762 delete arg3;
5763 }
5764 {
5765 if (temp4)
5766 delete arg4;
5767 }
5768 {
5769 if (temp5)
5770 delete arg5;
5771 }
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5777 PyObject *resultobj = 0;
5778 wxString *arg1 = 0 ;
5779 wxString *arg2 = 0 ;
5780 wxString const &arg3_defvalue = wxPyEmptyString ;
5781 wxString *arg3 = (wxString *) &arg3_defvalue ;
5782 wxWindow *arg4 = (wxWindow *) NULL ;
5783 wxString result;
5784 bool temp1 = false ;
5785 bool temp2 = false ;
5786 bool temp3 = false ;
5787 void *argp4 = 0 ;
5788 int res4 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 PyObject * obj3 = 0 ;
5793 char * kwnames[] = {
5794 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5795 };
5796
5797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5798 {
5799 arg1 = wxString_in_helper(obj0);
5800 if (arg1 == NULL) SWIG_fail;
5801 temp1 = true;
5802 }
5803 {
5804 arg2 = wxString_in_helper(obj1);
5805 if (arg2 == NULL) SWIG_fail;
5806 temp2 = true;
5807 }
5808 if (obj2) {
5809 {
5810 arg3 = wxString_in_helper(obj2);
5811 if (arg3 == NULL) SWIG_fail;
5812 temp3 = true;
5813 }
5814 }
5815 if (obj3) {
5816 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5817 if (!SWIG_IsOK(res4)) {
5818 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5819 }
5820 arg4 = reinterpret_cast< wxWindow * >(argp4);
5821 }
5822 {
5823 if (!wxPyCheckForApp()) SWIG_fail;
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5826 wxPyEndAllowThreads(__tstate);
5827 if (PyErr_Occurred()) SWIG_fail;
5828 }
5829 {
5830 #if wxUSE_UNICODE
5831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5832 #else
5833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5834 #endif
5835 }
5836 {
5837 if (temp1)
5838 delete arg1;
5839 }
5840 {
5841 if (temp2)
5842 delete arg2;
5843 }
5844 {
5845 if (temp3)
5846 delete arg3;
5847 }
5848 return resultobj;
5849 fail:
5850 {
5851 if (temp1)
5852 delete arg1;
5853 }
5854 {
5855 if (temp2)
5856 delete arg2;
5857 }
5858 {
5859 if (temp3)
5860 delete arg3;
5861 }
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj = 0;
5868 wxString *arg1 = 0 ;
5869 wxString *arg2 = 0 ;
5870 wxString const &arg3_defvalue = wxPyEmptyString ;
5871 wxString *arg3 = (wxString *) &arg3_defvalue ;
5872 wxWindow *arg4 = (wxWindow *) NULL ;
5873 wxString result;
5874 bool temp1 = false ;
5875 bool temp2 = false ;
5876 bool temp3 = false ;
5877 void *argp4 = 0 ;
5878 int res4 = 0 ;
5879 PyObject * obj0 = 0 ;
5880 PyObject * obj1 = 0 ;
5881 PyObject * obj2 = 0 ;
5882 PyObject * obj3 = 0 ;
5883 char * kwnames[] = {
5884 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5885 };
5886
5887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5888 {
5889 arg1 = wxString_in_helper(obj0);
5890 if (arg1 == NULL) SWIG_fail;
5891 temp1 = true;
5892 }
5893 {
5894 arg2 = wxString_in_helper(obj1);
5895 if (arg2 == NULL) SWIG_fail;
5896 temp2 = true;
5897 }
5898 if (obj2) {
5899 {
5900 arg3 = wxString_in_helper(obj2);
5901 if (arg3 == NULL) SWIG_fail;
5902 temp3 = true;
5903 }
5904 }
5905 if (obj3) {
5906 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5907 if (!SWIG_IsOK(res4)) {
5908 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5909 }
5910 arg4 = reinterpret_cast< wxWindow * >(argp4);
5911 }
5912 {
5913 if (!wxPyCheckForApp()) SWIG_fail;
5914 PyThreadState* __tstate = wxPyBeginAllowThreads();
5915 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5916 wxPyEndAllowThreads(__tstate);
5917 if (PyErr_Occurred()) SWIG_fail;
5918 }
5919 {
5920 #if wxUSE_UNICODE
5921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5922 #else
5923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5924 #endif
5925 }
5926 {
5927 if (temp1)
5928 delete arg1;
5929 }
5930 {
5931 if (temp2)
5932 delete arg2;
5933 }
5934 {
5935 if (temp3)
5936 delete arg3;
5937 }
5938 return resultobj;
5939 fail:
5940 {
5941 if (temp1)
5942 delete arg1;
5943 }
5944 {
5945 if (temp2)
5946 delete arg2;
5947 }
5948 {
5949 if (temp3)
5950 delete arg3;
5951 }
5952 return NULL;
5953 }
5954
5955
5956 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5957 PyObject *resultobj = 0;
5958 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5959 wxString *arg1 = (wxString *) &arg1_defvalue ;
5960 wxString const &arg2_defvalue = wxPyEmptyString ;
5961 wxString *arg2 = (wxString *) &arg2_defvalue ;
5962 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5963 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5964 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5965 wxWindow *arg5 = (wxWindow *) NULL ;
5966 wxString result;
5967 bool temp1 = false ;
5968 bool temp2 = false ;
5969 long val3 ;
5970 int ecode3 = 0 ;
5971 wxPoint temp4 ;
5972 void *argp5 = 0 ;
5973 int res5 = 0 ;
5974 PyObject * obj0 = 0 ;
5975 PyObject * obj1 = 0 ;
5976 PyObject * obj2 = 0 ;
5977 PyObject * obj3 = 0 ;
5978 PyObject * obj4 = 0 ;
5979 char * kwnames[] = {
5980 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5981 };
5982
5983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5984 if (obj0) {
5985 {
5986 arg1 = wxString_in_helper(obj0);
5987 if (arg1 == NULL) SWIG_fail;
5988 temp1 = true;
5989 }
5990 }
5991 if (obj1) {
5992 {
5993 arg2 = wxString_in_helper(obj1);
5994 if (arg2 == NULL) SWIG_fail;
5995 temp2 = true;
5996 }
5997 }
5998 if (obj2) {
5999 ecode3 = SWIG_AsVal_long(obj2, &val3);
6000 if (!SWIG_IsOK(ecode3)) {
6001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6002 }
6003 arg3 = static_cast< long >(val3);
6004 }
6005 if (obj3) {
6006 {
6007 arg4 = &temp4;
6008 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6009 }
6010 }
6011 if (obj4) {
6012 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6013 if (!SWIG_IsOK(res5)) {
6014 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6015 }
6016 arg5 = reinterpret_cast< wxWindow * >(argp5);
6017 }
6018 {
6019 if (!wxPyCheckForApp()) SWIG_fail;
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 {
6026 #if wxUSE_UNICODE
6027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6028 #else
6029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6030 #endif
6031 }
6032 {
6033 if (temp1)
6034 delete arg1;
6035 }
6036 {
6037 if (temp2)
6038 delete arg2;
6039 }
6040 return resultobj;
6041 fail:
6042 {
6043 if (temp1)
6044 delete arg1;
6045 }
6046 {
6047 if (temp2)
6048 delete arg2;
6049 }
6050 return NULL;
6051 }
6052
6053
6054 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj = 0;
6056 wxString *arg1 = 0 ;
6057 wxString const &arg2_defvalue = wxPyEmptyString ;
6058 wxString *arg2 = (wxString *) &arg2_defvalue ;
6059 wxString const &arg3_defvalue = wxPyEmptyString ;
6060 wxString *arg3 = (wxString *) &arg3_defvalue ;
6061 wxWindow *arg4 = (wxWindow *) NULL ;
6062 int arg5 = (int) -1 ;
6063 int arg6 = (int) -1 ;
6064 bool arg7 = (bool) true ;
6065 wxString result;
6066 bool temp1 = false ;
6067 bool temp2 = false ;
6068 bool temp3 = false ;
6069 void *argp4 = 0 ;
6070 int res4 = 0 ;
6071 int val5 ;
6072 int ecode5 = 0 ;
6073 int val6 ;
6074 int ecode6 = 0 ;
6075 bool val7 ;
6076 int ecode7 = 0 ;
6077 PyObject * obj0 = 0 ;
6078 PyObject * obj1 = 0 ;
6079 PyObject * obj2 = 0 ;
6080 PyObject * obj3 = 0 ;
6081 PyObject * obj4 = 0 ;
6082 PyObject * obj5 = 0 ;
6083 PyObject * obj6 = 0 ;
6084 char * kwnames[] = {
6085 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6086 };
6087
6088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6089 {
6090 arg1 = wxString_in_helper(obj0);
6091 if (arg1 == NULL) SWIG_fail;
6092 temp1 = true;
6093 }
6094 if (obj1) {
6095 {
6096 arg2 = wxString_in_helper(obj1);
6097 if (arg2 == NULL) SWIG_fail;
6098 temp2 = true;
6099 }
6100 }
6101 if (obj2) {
6102 {
6103 arg3 = wxString_in_helper(obj2);
6104 if (arg3 == NULL) SWIG_fail;
6105 temp3 = true;
6106 }
6107 }
6108 if (obj3) {
6109 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6110 if (!SWIG_IsOK(res4)) {
6111 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6112 }
6113 arg4 = reinterpret_cast< wxWindow * >(argp4);
6114 }
6115 if (obj4) {
6116 ecode5 = SWIG_AsVal_int(obj4, &val5);
6117 if (!SWIG_IsOK(ecode5)) {
6118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6119 }
6120 arg5 = static_cast< int >(val5);
6121 }
6122 if (obj5) {
6123 ecode6 = SWIG_AsVal_int(obj5, &val6);
6124 if (!SWIG_IsOK(ecode6)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6126 }
6127 arg6 = static_cast< int >(val6);
6128 }
6129 if (obj6) {
6130 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6131 if (!SWIG_IsOK(ecode7)) {
6132 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6133 }
6134 arg7 = static_cast< bool >(val7);
6135 }
6136 {
6137 if (!wxPyCheckForApp()) SWIG_fail;
6138 PyThreadState* __tstate = wxPyBeginAllowThreads();
6139 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6140 wxPyEndAllowThreads(__tstate);
6141 if (PyErr_Occurred()) SWIG_fail;
6142 }
6143 {
6144 #if wxUSE_UNICODE
6145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6146 #else
6147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6148 #endif
6149 }
6150 {
6151 if (temp1)
6152 delete arg1;
6153 }
6154 {
6155 if (temp2)
6156 delete arg2;
6157 }
6158 {
6159 if (temp3)
6160 delete arg3;
6161 }
6162 return resultobj;
6163 fail:
6164 {
6165 if (temp1)
6166 delete arg1;
6167 }
6168 {
6169 if (temp2)
6170 delete arg2;
6171 }
6172 {
6173 if (temp3)
6174 delete arg3;
6175 }
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj = 0;
6182 wxString *arg1 = 0 ;
6183 wxString const &arg2_defvalue = wxPyEmptyString ;
6184 wxString *arg2 = (wxString *) &arg2_defvalue ;
6185 wxString const &arg3_defvalue = wxPyEmptyString ;
6186 wxString *arg3 = (wxString *) &arg3_defvalue ;
6187 wxWindow *arg4 = (wxWindow *) NULL ;
6188 wxString result;
6189 bool temp1 = false ;
6190 bool temp2 = false ;
6191 bool temp3 = false ;
6192 void *argp4 = 0 ;
6193 int res4 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 PyObject * obj2 = 0 ;
6197 PyObject * obj3 = 0 ;
6198 char * kwnames[] = {
6199 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6200 };
6201
6202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6203 {
6204 arg1 = wxString_in_helper(obj0);
6205 if (arg1 == NULL) SWIG_fail;
6206 temp1 = true;
6207 }
6208 if (obj1) {
6209 {
6210 arg2 = wxString_in_helper(obj1);
6211 if (arg2 == NULL) SWIG_fail;
6212 temp2 = true;
6213 }
6214 }
6215 if (obj2) {
6216 {
6217 arg3 = wxString_in_helper(obj2);
6218 if (arg3 == NULL) SWIG_fail;
6219 temp3 = true;
6220 }
6221 }
6222 if (obj3) {
6223 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6224 if (!SWIG_IsOK(res4)) {
6225 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6226 }
6227 arg4 = reinterpret_cast< wxWindow * >(argp4);
6228 }
6229 {
6230 if (!wxPyCheckForApp()) SWIG_fail;
6231 PyThreadState* __tstate = wxPyBeginAllowThreads();
6232 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6233 wxPyEndAllowThreads(__tstate);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 {
6237 #if wxUSE_UNICODE
6238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6239 #else
6240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6241 #endif
6242 }
6243 {
6244 if (temp1)
6245 delete arg1;
6246 }
6247 {
6248 if (temp2)
6249 delete arg2;
6250 }
6251 {
6252 if (temp3)
6253 delete arg3;
6254 }
6255 return resultobj;
6256 fail:
6257 {
6258 if (temp1)
6259 delete arg1;
6260 }
6261 {
6262 if (temp2)
6263 delete arg2;
6264 }
6265 {
6266 if (temp3)
6267 delete arg3;
6268 }
6269 return NULL;
6270 }
6271
6272
6273 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6274 PyObject *resultobj = 0;
6275 wxString *arg1 = 0 ;
6276 wxString *arg2 = 0 ;
6277 int arg3 ;
6278 wxString *arg4 = (wxString *) 0 ;
6279 wxWindow *arg5 = (wxWindow *) NULL ;
6280 int arg6 = (int) -1 ;
6281 int arg7 = (int) -1 ;
6282 bool arg8 = (bool) true ;
6283 int arg9 = (int) 150 ;
6284 int arg10 = (int) 200 ;
6285 wxString result;
6286 bool temp1 = false ;
6287 bool temp2 = false ;
6288 void *argp5 = 0 ;
6289 int res5 = 0 ;
6290 int val6 ;
6291 int ecode6 = 0 ;
6292 int val7 ;
6293 int ecode7 = 0 ;
6294 bool val8 ;
6295 int ecode8 = 0 ;
6296 int val9 ;
6297 int ecode9 = 0 ;
6298 int val10 ;
6299 int ecode10 = 0 ;
6300 PyObject * obj0 = 0 ;
6301 PyObject * obj1 = 0 ;
6302 PyObject * obj2 = 0 ;
6303 PyObject * obj3 = 0 ;
6304 PyObject * obj4 = 0 ;
6305 PyObject * obj5 = 0 ;
6306 PyObject * obj6 = 0 ;
6307 PyObject * obj7 = 0 ;
6308 PyObject * obj8 = 0 ;
6309 char * kwnames[] = {
6310 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6311 };
6312
6313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6314 {
6315 arg1 = wxString_in_helper(obj0);
6316 if (arg1 == NULL) SWIG_fail;
6317 temp1 = true;
6318 }
6319 {
6320 arg2 = wxString_in_helper(obj1);
6321 if (arg2 == NULL) SWIG_fail;
6322 temp2 = true;
6323 }
6324 {
6325 arg3 = PyList_Size(obj2);
6326 arg4 = wxString_LIST_helper(obj2);
6327 if (arg4 == NULL) SWIG_fail;
6328 }
6329 if (obj3) {
6330 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6331 if (!SWIG_IsOK(res5)) {
6332 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6333 }
6334 arg5 = reinterpret_cast< wxWindow * >(argp5);
6335 }
6336 if (obj4) {
6337 ecode6 = SWIG_AsVal_int(obj4, &val6);
6338 if (!SWIG_IsOK(ecode6)) {
6339 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6340 }
6341 arg6 = static_cast< int >(val6);
6342 }
6343 if (obj5) {
6344 ecode7 = SWIG_AsVal_int(obj5, &val7);
6345 if (!SWIG_IsOK(ecode7)) {
6346 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6347 }
6348 arg7 = static_cast< int >(val7);
6349 }
6350 if (obj6) {
6351 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6352 if (!SWIG_IsOK(ecode8)) {
6353 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6354 }
6355 arg8 = static_cast< bool >(val8);
6356 }
6357 if (obj7) {
6358 ecode9 = SWIG_AsVal_int(obj7, &val9);
6359 if (!SWIG_IsOK(ecode9)) {
6360 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6361 }
6362 arg9 = static_cast< int >(val9);
6363 }
6364 if (obj8) {
6365 ecode10 = SWIG_AsVal_int(obj8, &val10);
6366 if (!SWIG_IsOK(ecode10)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6368 }
6369 arg10 = static_cast< int >(val10);
6370 }
6371 {
6372 if (!wxPyCheckForApp()) SWIG_fail;
6373 PyThreadState* __tstate = wxPyBeginAllowThreads();
6374 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 {
6379 #if wxUSE_UNICODE
6380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6381 #else
6382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6383 #endif
6384 }
6385 {
6386 if (temp1)
6387 delete arg1;
6388 }
6389 {
6390 if (temp2)
6391 delete arg2;
6392 }
6393 {
6394 if (arg4) delete [] arg4;
6395 }
6396 return resultobj;
6397 fail:
6398 {
6399 if (temp1)
6400 delete arg1;
6401 }
6402 {
6403 if (temp2)
6404 delete arg2;
6405 }
6406 {
6407 if (arg4) delete [] arg4;
6408 }
6409 return NULL;
6410 }
6411
6412
6413 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6414 PyObject *resultobj = 0;
6415 wxString *arg1 = 0 ;
6416 wxString *arg2 = 0 ;
6417 int arg3 ;
6418 wxString *arg4 = (wxString *) 0 ;
6419 wxWindow *arg5 = (wxWindow *) NULL ;
6420 int arg6 = (int) -1 ;
6421 int arg7 = (int) -1 ;
6422 bool arg8 = (bool) true ;
6423 int arg9 = (int) 150 ;
6424 int arg10 = (int) 200 ;
6425 int result;
6426 bool temp1 = false ;
6427 bool temp2 = false ;
6428 void *argp5 = 0 ;
6429 int res5 = 0 ;
6430 int val6 ;
6431 int ecode6 = 0 ;
6432 int val7 ;
6433 int ecode7 = 0 ;
6434 bool val8 ;
6435 int ecode8 = 0 ;
6436 int val9 ;
6437 int ecode9 = 0 ;
6438 int val10 ;
6439 int ecode10 = 0 ;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 PyObject * obj2 = 0 ;
6443 PyObject * obj3 = 0 ;
6444 PyObject * obj4 = 0 ;
6445 PyObject * obj5 = 0 ;
6446 PyObject * obj6 = 0 ;
6447 PyObject * obj7 = 0 ;
6448 PyObject * obj8 = 0 ;
6449 char * kwnames[] = {
6450 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6451 };
6452
6453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6454 {
6455 arg1 = wxString_in_helper(obj0);
6456 if (arg1 == NULL) SWIG_fail;
6457 temp1 = true;
6458 }
6459 {
6460 arg2 = wxString_in_helper(obj1);
6461 if (arg2 == NULL) SWIG_fail;
6462 temp2 = true;
6463 }
6464 {
6465 arg3 = PyList_Size(obj2);
6466 arg4 = wxString_LIST_helper(obj2);
6467 if (arg4 == NULL) SWIG_fail;
6468 }
6469 if (obj3) {
6470 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6471 if (!SWIG_IsOK(res5)) {
6472 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6473 }
6474 arg5 = reinterpret_cast< wxWindow * >(argp5);
6475 }
6476 if (obj4) {
6477 ecode6 = SWIG_AsVal_int(obj4, &val6);
6478 if (!SWIG_IsOK(ecode6)) {
6479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6480 }
6481 arg6 = static_cast< int >(val6);
6482 }
6483 if (obj5) {
6484 ecode7 = SWIG_AsVal_int(obj5, &val7);
6485 if (!SWIG_IsOK(ecode7)) {
6486 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6487 }
6488 arg7 = static_cast< int >(val7);
6489 }
6490 if (obj6) {
6491 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6492 if (!SWIG_IsOK(ecode8)) {
6493 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6494 }
6495 arg8 = static_cast< bool >(val8);
6496 }
6497 if (obj7) {
6498 ecode9 = SWIG_AsVal_int(obj7, &val9);
6499 if (!SWIG_IsOK(ecode9)) {
6500 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6501 }
6502 arg9 = static_cast< int >(val9);
6503 }
6504 if (obj8) {
6505 ecode10 = SWIG_AsVal_int(obj8, &val10);
6506 if (!SWIG_IsOK(ecode10)) {
6507 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6508 }
6509 arg10 = static_cast< int >(val10);
6510 }
6511 {
6512 if (!wxPyCheckForApp()) SWIG_fail;
6513 PyThreadState* __tstate = wxPyBeginAllowThreads();
6514 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 resultobj = SWIG_From_int(static_cast< int >(result));
6519 {
6520 if (temp1)
6521 delete arg1;
6522 }
6523 {
6524 if (temp2)
6525 delete arg2;
6526 }
6527 {
6528 if (arg4) delete [] arg4;
6529 }
6530 return resultobj;
6531 fail:
6532 {
6533 if (temp1)
6534 delete arg1;
6535 }
6536 {
6537 if (temp2)
6538 delete arg2;
6539 }
6540 {
6541 if (arg4) delete [] arg4;
6542 }
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6548 PyObject *resultobj = 0;
6549 wxString *arg1 = 0 ;
6550 wxString const &arg2_defvalue = wxPyEmptyString ;
6551 wxString *arg2 = (wxString *) &arg2_defvalue ;
6552 int arg3 = (int) wxOK|wxCENTRE ;
6553 wxWindow *arg4 = (wxWindow *) NULL ;
6554 int arg5 = (int) -1 ;
6555 int arg6 = (int) -1 ;
6556 int result;
6557 bool temp1 = false ;
6558 bool temp2 = false ;
6559 int val3 ;
6560 int ecode3 = 0 ;
6561 void *argp4 = 0 ;
6562 int res4 = 0 ;
6563 int val5 ;
6564 int ecode5 = 0 ;
6565 int val6 ;
6566 int ecode6 = 0 ;
6567 PyObject * obj0 = 0 ;
6568 PyObject * obj1 = 0 ;
6569 PyObject * obj2 = 0 ;
6570 PyObject * obj3 = 0 ;
6571 PyObject * obj4 = 0 ;
6572 PyObject * obj5 = 0 ;
6573 char * kwnames[] = {
6574 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6575 };
6576
6577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6578 {
6579 arg1 = wxString_in_helper(obj0);
6580 if (arg1 == NULL) SWIG_fail;
6581 temp1 = true;
6582 }
6583 if (obj1) {
6584 {
6585 arg2 = wxString_in_helper(obj1);
6586 if (arg2 == NULL) SWIG_fail;
6587 temp2 = true;
6588 }
6589 }
6590 if (obj2) {
6591 ecode3 = SWIG_AsVal_int(obj2, &val3);
6592 if (!SWIG_IsOK(ecode3)) {
6593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6594 }
6595 arg3 = static_cast< int >(val3);
6596 }
6597 if (obj3) {
6598 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6599 if (!SWIG_IsOK(res4)) {
6600 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6601 }
6602 arg4 = reinterpret_cast< wxWindow * >(argp4);
6603 }
6604 if (obj4) {
6605 ecode5 = SWIG_AsVal_int(obj4, &val5);
6606 if (!SWIG_IsOK(ecode5)) {
6607 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6608 }
6609 arg5 = static_cast< int >(val5);
6610 }
6611 if (obj5) {
6612 ecode6 = SWIG_AsVal_int(obj5, &val6);
6613 if (!SWIG_IsOK(ecode6)) {
6614 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6615 }
6616 arg6 = static_cast< int >(val6);
6617 }
6618 {
6619 if (!wxPyCheckForApp()) SWIG_fail;
6620 PyThreadState* __tstate = wxPyBeginAllowThreads();
6621 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6622 wxPyEndAllowThreads(__tstate);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_From_int(static_cast< int >(result));
6626 {
6627 if (temp1)
6628 delete arg1;
6629 }
6630 {
6631 if (temp2)
6632 delete arg2;
6633 }
6634 return resultobj;
6635 fail:
6636 {
6637 if (temp1)
6638 delete arg1;
6639 }
6640 {
6641 if (temp2)
6642 delete arg2;
6643 }
6644 return NULL;
6645 }
6646
6647
6648 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6649 PyObject *resultobj = 0;
6650 wxString *arg1 = 0 ;
6651 wxString *arg2 = 0 ;
6652 wxString *arg3 = 0 ;
6653 long arg4 ;
6654 long arg5 = (long) 0 ;
6655 long arg6 = (long) 100 ;
6656 wxWindow *arg7 = (wxWindow *) NULL ;
6657 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6658 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6659 long result;
6660 bool temp1 = false ;
6661 bool temp2 = false ;
6662 bool temp3 = false ;
6663 long val4 ;
6664 int ecode4 = 0 ;
6665 long val5 ;
6666 int ecode5 = 0 ;
6667 long val6 ;
6668 int ecode6 = 0 ;
6669 void *argp7 = 0 ;
6670 int res7 = 0 ;
6671 wxPoint temp8 ;
6672 PyObject * obj0 = 0 ;
6673 PyObject * obj1 = 0 ;
6674 PyObject * obj2 = 0 ;
6675 PyObject * obj3 = 0 ;
6676 PyObject * obj4 = 0 ;
6677 PyObject * obj5 = 0 ;
6678 PyObject * obj6 = 0 ;
6679 PyObject * obj7 = 0 ;
6680 char * kwnames[] = {
6681 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6682 };
6683
6684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6685 {
6686 arg1 = wxString_in_helper(obj0);
6687 if (arg1 == NULL) SWIG_fail;
6688 temp1 = true;
6689 }
6690 {
6691 arg2 = wxString_in_helper(obj1);
6692 if (arg2 == NULL) SWIG_fail;
6693 temp2 = true;
6694 }
6695 {
6696 arg3 = wxString_in_helper(obj2);
6697 if (arg3 == NULL) SWIG_fail;
6698 temp3 = true;
6699 }
6700 ecode4 = SWIG_AsVal_long(obj3, &val4);
6701 if (!SWIG_IsOK(ecode4)) {
6702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6703 }
6704 arg4 = static_cast< long >(val4);
6705 if (obj4) {
6706 ecode5 = SWIG_AsVal_long(obj4, &val5);
6707 if (!SWIG_IsOK(ecode5)) {
6708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6709 }
6710 arg5 = static_cast< long >(val5);
6711 }
6712 if (obj5) {
6713 ecode6 = SWIG_AsVal_long(obj5, &val6);
6714 if (!SWIG_IsOK(ecode6)) {
6715 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6716 }
6717 arg6 = static_cast< long >(val6);
6718 }
6719 if (obj6) {
6720 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6721 if (!SWIG_IsOK(res7)) {
6722 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6723 }
6724 arg7 = reinterpret_cast< wxWindow * >(argp7);
6725 }
6726 if (obj7) {
6727 {
6728 arg8 = &temp8;
6729 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6730 }
6731 }
6732 {
6733 if (!wxPyCheckForApp()) SWIG_fail;
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 resultobj = SWIG_From_long(static_cast< long >(result));
6740 {
6741 if (temp1)
6742 delete arg1;
6743 }
6744 {
6745 if (temp2)
6746 delete arg2;
6747 }
6748 {
6749 if (temp3)
6750 delete arg3;
6751 }
6752 return resultobj;
6753 fail:
6754 {
6755 if (temp1)
6756 delete arg1;
6757 }
6758 {
6759 if (temp2)
6760 delete arg2;
6761 }
6762 {
6763 if (temp3)
6764 delete arg3;
6765 }
6766 return NULL;
6767 }
6768
6769
6770 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 PyObject *resultobj = 0;
6772 bool result;
6773
6774 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6775 {
6776 if (!wxPyCheckForApp()) SWIG_fail;
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (bool)wxColourDisplay();
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 {
6783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6784 }
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6792 PyObject *resultobj = 0;
6793 int result;
6794
6795 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6796 {
6797 if (!wxPyCheckForApp()) SWIG_fail;
6798 PyThreadState* __tstate = wxPyBeginAllowThreads();
6799 result = (int)wxDisplayDepth();
6800 wxPyEndAllowThreads(__tstate);
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_From_int(static_cast< int >(result));
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6811 PyObject *resultobj = 0;
6812 int result;
6813
6814 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6815 {
6816 if (!wxPyCheckForApp()) SWIG_fail;
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 result = (int)wxGetDisplayDepth();
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_From_int(static_cast< int >(result));
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 int *arg1 = (int *) 0 ;
6832 int *arg2 = (int *) 0 ;
6833 int temp1 ;
6834 int res1 = SWIG_TMPOBJ ;
6835 int temp2 ;
6836 int res2 = SWIG_TMPOBJ ;
6837
6838 arg1 = &temp1;
6839 arg2 = &temp2;
6840 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6841 {
6842 if (!wxPyCheckForApp()) SWIG_fail;
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 wxDisplaySize(arg1,arg2);
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_Py_Void();
6849 if (SWIG_IsTmpObj(res1)) {
6850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6851 } else {
6852 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6854 }
6855 if (SWIG_IsTmpObj(res2)) {
6856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6857 } else {
6858 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6860 }
6861 return resultobj;
6862 fail:
6863 return NULL;
6864 }
6865
6866
6867 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6868 PyObject *resultobj = 0;
6869 wxSize result;
6870
6871 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6872 {
6873 if (!wxPyCheckForApp()) SWIG_fail;
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 result = wxGetDisplaySize();
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6880 return resultobj;
6881 fail:
6882 return NULL;
6883 }
6884
6885
6886 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6887 PyObject *resultobj = 0;
6888 int *arg1 = (int *) 0 ;
6889 int *arg2 = (int *) 0 ;
6890 int temp1 ;
6891 int res1 = SWIG_TMPOBJ ;
6892 int temp2 ;
6893 int res2 = SWIG_TMPOBJ ;
6894
6895 arg1 = &temp1;
6896 arg2 = &temp2;
6897 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6898 {
6899 if (!wxPyCheckForApp()) SWIG_fail;
6900 PyThreadState* __tstate = wxPyBeginAllowThreads();
6901 wxDisplaySizeMM(arg1,arg2);
6902 wxPyEndAllowThreads(__tstate);
6903 if (PyErr_Occurred()) SWIG_fail;
6904 }
6905 resultobj = SWIG_Py_Void();
6906 if (SWIG_IsTmpObj(res1)) {
6907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6908 } else {
6909 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6911 }
6912 if (SWIG_IsTmpObj(res2)) {
6913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6914 } else {
6915 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6917 }
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6925 PyObject *resultobj = 0;
6926 wxSize result;
6927
6928 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6929 {
6930 if (!wxPyCheckForApp()) SWIG_fail;
6931 PyThreadState* __tstate = wxPyBeginAllowThreads();
6932 result = wxGetDisplaySizeMM();
6933 wxPyEndAllowThreads(__tstate);
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6944 PyObject *resultobj = 0;
6945 int *arg1 = (int *) 0 ;
6946 int *arg2 = (int *) 0 ;
6947 int *arg3 = (int *) 0 ;
6948 int *arg4 = (int *) 0 ;
6949 int temp1 ;
6950 int res1 = SWIG_TMPOBJ ;
6951 int temp2 ;
6952 int res2 = SWIG_TMPOBJ ;
6953 int temp3 ;
6954 int res3 = SWIG_TMPOBJ ;
6955 int temp4 ;
6956 int res4 = SWIG_TMPOBJ ;
6957
6958 arg1 = &temp1;
6959 arg2 = &temp2;
6960 arg3 = &temp3;
6961 arg4 = &temp4;
6962 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6963 {
6964 if (!wxPyCheckForApp()) SWIG_fail;
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 if (SWIG_IsTmpObj(res1)) {
6972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6973 } else {
6974 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6976 }
6977 if (SWIG_IsTmpObj(res2)) {
6978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6979 } else {
6980 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6982 }
6983 if (SWIG_IsTmpObj(res3)) {
6984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6985 } else {
6986 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6988 }
6989 if (SWIG_IsTmpObj(res4)) {
6990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6991 } else {
6992 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6994 }
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7002 PyObject *resultobj = 0;
7003 wxRect result;
7004
7005 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7006 {
7007 if (!wxPyCheckForApp()) SWIG_fail;
7008 PyThreadState* __tstate = wxPyBeginAllowThreads();
7009 result = wxGetClientDisplayRect();
7010 wxPyEndAllowThreads(__tstate);
7011 if (PyErr_Occurred()) SWIG_fail;
7012 }
7013 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7014 return resultobj;
7015 fail:
7016 return NULL;
7017 }
7018
7019
7020 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7021 PyObject *resultobj = 0;
7022 wxCursor *arg1 = 0 ;
7023 void *argp1 = 0 ;
7024 int res1 = 0 ;
7025 PyObject * obj0 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "cursor", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7034 }
7035 if (!argp1) {
7036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7037 }
7038 arg1 = reinterpret_cast< wxCursor * >(argp1);
7039 {
7040 if (!wxPyCheckForApp()) SWIG_fail;
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 wxSetCursor(*arg1);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_Py_Void();
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7054 PyObject *resultobj = 0;
7055 void *result = 0 ;
7056
7057 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7058 {
7059 if (!wxPyCheckForApp()) SWIG_fail;
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 result = (void *)wxGetXDisplay();
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7075 void *argp1 = 0 ;
7076 int res1 = 0 ;
7077 PyObject * obj0 = 0 ;
7078 char * kwnames[] = {
7079 (char *) "cursor", NULL
7080 };
7081
7082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7083 if (obj0) {
7084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7085 if (!SWIG_IsOK(res1)) {
7086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7087 }
7088 arg1 = reinterpret_cast< wxCursor * >(argp1);
7089 }
7090 {
7091 if (!wxPyCheckForApp()) SWIG_fail;
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 wxBeginBusyCursor(arg1);
7094 wxPyEndAllowThreads(__tstate);
7095 if (PyErr_Occurred()) SWIG_fail;
7096 }
7097 resultobj = SWIG_Py_Void();
7098 return resultobj;
7099 fail:
7100 return NULL;
7101 }
7102
7103
7104 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7105 PyObject *resultobj = 0;
7106 wxPoint result;
7107
7108 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7109 {
7110 if (!wxPyCheckForApp()) SWIG_fail;
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 result = wxGetMousePosition();
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7124 PyObject *resultobj = 0;
7125 wxWindow *result = 0 ;
7126
7127 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7128 {
7129 if (!wxPyCheckForApp()) SWIG_fail;
7130 PyThreadState* __tstate = wxPyBeginAllowThreads();
7131 result = (wxWindow *)FindWindowAtPointer();
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 {
7136 resultobj = wxPyMake_wxObject(result, 0);
7137 }
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7145 PyObject *resultobj = 0;
7146 wxWindow *result = 0 ;
7147
7148 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7149 {
7150 if (!wxPyCheckForApp()) SWIG_fail;
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 result = (wxWindow *)wxGetActiveWindow();
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 {
7157 resultobj = wxPyMake_wxObject(result, 0);
7158 }
7159 return resultobj;
7160 fail:
7161 return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7166 PyObject *resultobj = 0;
7167 wxPoint *arg1 = 0 ;
7168 wxWindow *result = 0 ;
7169 wxPoint temp1 ;
7170 PyObject * obj0 = 0 ;
7171 char * kwnames[] = {
7172 (char *) "pt", NULL
7173 };
7174
7175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7176 {
7177 arg1 = &temp1;
7178 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7179 }
7180 {
7181 if (!wxPyCheckForApp()) SWIG_fail;
7182 PyThreadState* __tstate = wxPyBeginAllowThreads();
7183 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7184 wxPyEndAllowThreads(__tstate);
7185 if (PyErr_Occurred()) SWIG_fail;
7186 }
7187 {
7188 resultobj = wxPyMake_wxObject(result, 0);
7189 }
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj = 0;
7198 wxPoint *arg1 = 0 ;
7199 wxWindow *result = 0 ;
7200 wxPoint temp1 ;
7201 PyObject * obj0 = 0 ;
7202 char * kwnames[] = {
7203 (char *) "pt", NULL
7204 };
7205
7206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7207 {
7208 arg1 = &temp1;
7209 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7210 }
7211 {
7212 if (!wxPyCheckForApp()) SWIG_fail;
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7215 wxPyEndAllowThreads(__tstate);
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 {
7219 resultobj = wxPyMake_wxObject(result, 0);
7220 }
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj = 0;
7229 wxWindow *arg1 = (wxWindow *) 0 ;
7230 wxWindow *result = 0 ;
7231 void *argp1 = 0 ;
7232 int res1 = 0 ;
7233 PyObject * obj0 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "win", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7242 }
7243 arg1 = reinterpret_cast< wxWindow * >(argp1);
7244 {
7245 if (!wxPyCheckForApp()) SWIG_fail;
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (wxWindow *)wxGetTopLevelParent(arg1);
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 {
7252 resultobj = wxPyMake_wxObject(result, 0);
7253 }
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj = 0;
7262 wxString *arg1 = 0 ;
7263 bool result;
7264 bool temp1 = false ;
7265 PyObject * obj0 = 0 ;
7266 char * kwnames[] = {
7267 (char *) "url", NULL
7268 };
7269
7270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7271 {
7272 arg1 = wxString_in_helper(obj0);
7273 if (arg1 == NULL) SWIG_fail;
7274 temp1 = true;
7275 }
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7279 wxPyEndAllowThreads(__tstate);
7280 if (PyErr_Occurred()) SWIG_fail;
7281 }
7282 {
7283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7284 }
7285 {
7286 if (temp1)
7287 delete arg1;
7288 }
7289 return resultobj;
7290 fail:
7291 {
7292 if (temp1)
7293 delete arg1;
7294 }
7295 return NULL;
7296 }
7297
7298
7299 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj = 0;
7301 wxKeyCode arg1 ;
7302 bool result;
7303 int val1 ;
7304 int ecode1 = 0 ;
7305 PyObject * obj0 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "key", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7311 ecode1 = SWIG_AsVal_int(obj0, &val1);
7312 if (!SWIG_IsOK(ecode1)) {
7313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7314 }
7315 arg1 = static_cast< wxKeyCode >(val1);
7316 {
7317 if (!wxPyCheckForApp()) SWIG_fail;
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (bool)wxGetKeyState(arg1);
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 {
7324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7325 }
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7333 PyObject *resultobj = 0;
7334 wxMouseState *result = 0 ;
7335
7336 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 result = (wxMouseState *)new wxMouseState();
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7351 PyObject *resultobj = 0;
7352 wxMouseState *arg1 = (wxMouseState *) 0 ;
7353 void *argp1 = 0 ;
7354 int res1 = 0 ;
7355 PyObject *swig_obj[1] ;
7356
7357 if (!args) SWIG_fail;
7358 swig_obj[0] = args;
7359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7362 }
7363 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 delete arg1;
7367
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 resultobj = SWIG_Py_Void();
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7379 PyObject *resultobj = 0;
7380 wxMouseState *arg1 = (wxMouseState *) 0 ;
7381 int result;
7382 void *argp1 = 0 ;
7383 int res1 = 0 ;
7384 PyObject *swig_obj[1] ;
7385
7386 if (!args) SWIG_fail;
7387 swig_obj[0] = args;
7388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7391 }
7392 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 result = (int)(arg1)->GetX();
7396 wxPyEndAllowThreads(__tstate);
7397 if (PyErr_Occurred()) SWIG_fail;
7398 }
7399 resultobj = SWIG_From_int(static_cast< int >(result));
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7407 PyObject *resultobj = 0;
7408 wxMouseState *arg1 = (wxMouseState *) 0 ;
7409 int result;
7410 void *argp1 = 0 ;
7411 int res1 = 0 ;
7412 PyObject *swig_obj[1] ;
7413
7414 if (!args) SWIG_fail;
7415 swig_obj[0] = args;
7416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7417 if (!SWIG_IsOK(res1)) {
7418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7419 }
7420 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7421 {
7422 PyThreadState* __tstate = wxPyBeginAllowThreads();
7423 result = (int)(arg1)->GetY();
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 resultobj = SWIG_From_int(static_cast< int >(result));
7428 return resultobj;
7429 fail:
7430 return NULL;
7431 }
7432
7433
7434 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7435 PyObject *resultobj = 0;
7436 wxMouseState *arg1 = (wxMouseState *) 0 ;
7437 bool result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 PyObject *swig_obj[1] ;
7441
7442 if (!args) SWIG_fail;
7443 swig_obj[0] = args;
7444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7447 }
7448 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 result = (bool)(arg1)->LeftDown();
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 {
7456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7457 }
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7465 PyObject *resultobj = 0;
7466 wxMouseState *arg1 = (wxMouseState *) 0 ;
7467 bool result;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 PyObject *swig_obj[1] ;
7471
7472 if (!args) SWIG_fail;
7473 swig_obj[0] = args;
7474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7477 }
7478 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7479 {
7480 PyThreadState* __tstate = wxPyBeginAllowThreads();
7481 result = (bool)(arg1)->MiddleDown();
7482 wxPyEndAllowThreads(__tstate);
7483 if (PyErr_Occurred()) SWIG_fail;
7484 }
7485 {
7486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7487 }
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7495 PyObject *resultobj = 0;
7496 wxMouseState *arg1 = (wxMouseState *) 0 ;
7497 bool result;
7498 void *argp1 = 0 ;
7499 int res1 = 0 ;
7500 PyObject *swig_obj[1] ;
7501
7502 if (!args) SWIG_fail;
7503 swig_obj[0] = args;
7504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7505 if (!SWIG_IsOK(res1)) {
7506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7507 }
7508 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)(arg1)->RightDown();
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7525 PyObject *resultobj = 0;
7526 wxMouseState *arg1 = (wxMouseState *) 0 ;
7527 bool result;
7528 void *argp1 = 0 ;
7529 int res1 = 0 ;
7530 PyObject *swig_obj[1] ;
7531
7532 if (!args) SWIG_fail;
7533 swig_obj[0] = args;
7534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7537 }
7538 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)(arg1)->ControlDown();
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 {
7546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7547 }
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7555 PyObject *resultobj = 0;
7556 wxMouseState *arg1 = (wxMouseState *) 0 ;
7557 bool result;
7558 void *argp1 = 0 ;
7559 int res1 = 0 ;
7560 PyObject *swig_obj[1] ;
7561
7562 if (!args) SWIG_fail;
7563 swig_obj[0] = args;
7564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7565 if (!SWIG_IsOK(res1)) {
7566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7567 }
7568 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (bool)(arg1)->ShiftDown();
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 {
7576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7577 }
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7585 PyObject *resultobj = 0;
7586 wxMouseState *arg1 = (wxMouseState *) 0 ;
7587 bool result;
7588 void *argp1 = 0 ;
7589 int res1 = 0 ;
7590 PyObject *swig_obj[1] ;
7591
7592 if (!args) SWIG_fail;
7593 swig_obj[0] = args;
7594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7595 if (!SWIG_IsOK(res1)) {
7596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7597 }
7598 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 result = (bool)(arg1)->AltDown();
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 {
7606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7607 }
7608 return resultobj;
7609 fail:
7610 return NULL;
7611 }
7612
7613
7614 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7615 PyObject *resultobj = 0;
7616 wxMouseState *arg1 = (wxMouseState *) 0 ;
7617 bool result;
7618 void *argp1 = 0 ;
7619 int res1 = 0 ;
7620 PyObject *swig_obj[1] ;
7621
7622 if (!args) SWIG_fail;
7623 swig_obj[0] = args;
7624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7625 if (!SWIG_IsOK(res1)) {
7626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7627 }
7628 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 result = (bool)(arg1)->MetaDown();
7632 wxPyEndAllowThreads(__tstate);
7633 if (PyErr_Occurred()) SWIG_fail;
7634 }
7635 {
7636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7637 }
7638 return resultobj;
7639 fail:
7640 return NULL;
7641 }
7642
7643
7644 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7645 PyObject *resultobj = 0;
7646 wxMouseState *arg1 = (wxMouseState *) 0 ;
7647 bool result;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 PyObject *swig_obj[1] ;
7651
7652 if (!args) SWIG_fail;
7653 swig_obj[0] = args;
7654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7655 if (!SWIG_IsOK(res1)) {
7656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7657 }
7658 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7659 {
7660 PyThreadState* __tstate = wxPyBeginAllowThreads();
7661 result = (bool)(arg1)->CmdDown();
7662 wxPyEndAllowThreads(__tstate);
7663 if (PyErr_Occurred()) SWIG_fail;
7664 }
7665 {
7666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7667 }
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj = 0;
7676 wxMouseState *arg1 = (wxMouseState *) 0 ;
7677 int arg2 ;
7678 void *argp1 = 0 ;
7679 int res1 = 0 ;
7680 int val2 ;
7681 int ecode2 = 0 ;
7682 PyObject * obj0 = 0 ;
7683 PyObject * obj1 = 0 ;
7684 char * kwnames[] = {
7685 (char *) "self",(char *) "x", NULL
7686 };
7687
7688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7690 if (!SWIG_IsOK(res1)) {
7691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7692 }
7693 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7694 ecode2 = SWIG_AsVal_int(obj1, &val2);
7695 if (!SWIG_IsOK(ecode2)) {
7696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7697 }
7698 arg2 = static_cast< int >(val2);
7699 {
7700 PyThreadState* __tstate = wxPyBeginAllowThreads();
7701 (arg1)->SetX(arg2);
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 resultobj = SWIG_Py_Void();
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj = 0;
7714 wxMouseState *arg1 = (wxMouseState *) 0 ;
7715 int arg2 ;
7716 void *argp1 = 0 ;
7717 int res1 = 0 ;
7718 int val2 ;
7719 int ecode2 = 0 ;
7720 PyObject * obj0 = 0 ;
7721 PyObject * obj1 = 0 ;
7722 char * kwnames[] = {
7723 (char *) "self",(char *) "y", NULL
7724 };
7725
7726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7728 if (!SWIG_IsOK(res1)) {
7729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7730 }
7731 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7732 ecode2 = SWIG_AsVal_int(obj1, &val2);
7733 if (!SWIG_IsOK(ecode2)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7735 }
7736 arg2 = static_cast< int >(val2);
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 (arg1)->SetY(arg2);
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 resultobj = SWIG_Py_Void();
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj = 0;
7752 wxMouseState *arg1 = (wxMouseState *) 0 ;
7753 bool arg2 ;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 bool val2 ;
7757 int ecode2 = 0 ;
7758 PyObject * obj0 = 0 ;
7759 PyObject * obj1 = 0 ;
7760 char * kwnames[] = {
7761 (char *) "self",(char *) "down", NULL
7762 };
7763
7764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7766 if (!SWIG_IsOK(res1)) {
7767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7768 }
7769 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7771 if (!SWIG_IsOK(ecode2)) {
7772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7773 }
7774 arg2 = static_cast< bool >(val2);
7775 {
7776 PyThreadState* __tstate = wxPyBeginAllowThreads();
7777 (arg1)->SetLeftDown(arg2);
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 resultobj = SWIG_Py_Void();
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj = 0;
7790 wxMouseState *arg1 = (wxMouseState *) 0 ;
7791 bool arg2 ;
7792 void *argp1 = 0 ;
7793 int res1 = 0 ;
7794 bool val2 ;
7795 int ecode2 = 0 ;
7796 PyObject * obj0 = 0 ;
7797 PyObject * obj1 = 0 ;
7798 char * kwnames[] = {
7799 (char *) "self",(char *) "down", NULL
7800 };
7801
7802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7804 if (!SWIG_IsOK(res1)) {
7805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7806 }
7807 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7809 if (!SWIG_IsOK(ecode2)) {
7810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7811 }
7812 arg2 = static_cast< bool >(val2);
7813 {
7814 PyThreadState* __tstate = wxPyBeginAllowThreads();
7815 (arg1)->SetMiddleDown(arg2);
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 resultobj = SWIG_Py_Void();
7820 return resultobj;
7821 fail:
7822 return NULL;
7823 }
7824
7825
7826 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7827 PyObject *resultobj = 0;
7828 wxMouseState *arg1 = (wxMouseState *) 0 ;
7829 bool arg2 ;
7830 void *argp1 = 0 ;
7831 int res1 = 0 ;
7832 bool val2 ;
7833 int ecode2 = 0 ;
7834 PyObject * obj0 = 0 ;
7835 PyObject * obj1 = 0 ;
7836 char * kwnames[] = {
7837 (char *) "self",(char *) "down", NULL
7838 };
7839
7840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7842 if (!SWIG_IsOK(res1)) {
7843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7844 }
7845 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7846 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7847 if (!SWIG_IsOK(ecode2)) {
7848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7849 }
7850 arg2 = static_cast< bool >(val2);
7851 {
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 (arg1)->SetRightDown(arg2);
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 resultobj = SWIG_Py_Void();
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj = 0;
7866 wxMouseState *arg1 = (wxMouseState *) 0 ;
7867 bool arg2 ;
7868 void *argp1 = 0 ;
7869 int res1 = 0 ;
7870 bool val2 ;
7871 int ecode2 = 0 ;
7872 PyObject * obj0 = 0 ;
7873 PyObject * obj1 = 0 ;
7874 char * kwnames[] = {
7875 (char *) "self",(char *) "down", NULL
7876 };
7877
7878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7880 if (!SWIG_IsOK(res1)) {
7881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7882 }
7883 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7884 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7887 }
7888 arg2 = static_cast< bool >(val2);
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 (arg1)->SetControlDown(arg2);
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 resultobj = SWIG_Py_Void();
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7903 PyObject *resultobj = 0;
7904 wxMouseState *arg1 = (wxMouseState *) 0 ;
7905 bool arg2 ;
7906 void *argp1 = 0 ;
7907 int res1 = 0 ;
7908 bool val2 ;
7909 int ecode2 = 0 ;
7910 PyObject * obj0 = 0 ;
7911 PyObject * obj1 = 0 ;
7912 char * kwnames[] = {
7913 (char *) "self",(char *) "down", NULL
7914 };
7915
7916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7918 if (!SWIG_IsOK(res1)) {
7919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7920 }
7921 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7922 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7923 if (!SWIG_IsOK(ecode2)) {
7924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7925 }
7926 arg2 = static_cast< bool >(val2);
7927 {
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 (arg1)->SetShiftDown(arg2);
7930 wxPyEndAllowThreads(__tstate);
7931 if (PyErr_Occurred()) SWIG_fail;
7932 }
7933 resultobj = SWIG_Py_Void();
7934 return resultobj;
7935 fail:
7936 return NULL;
7937 }
7938
7939
7940 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7941 PyObject *resultobj = 0;
7942 wxMouseState *arg1 = (wxMouseState *) 0 ;
7943 bool arg2 ;
7944 void *argp1 = 0 ;
7945 int res1 = 0 ;
7946 bool val2 ;
7947 int ecode2 = 0 ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 char * kwnames[] = {
7951 (char *) "self",(char *) "down", NULL
7952 };
7953
7954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7956 if (!SWIG_IsOK(res1)) {
7957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7958 }
7959 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7961 if (!SWIG_IsOK(ecode2)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7963 }
7964 arg2 = static_cast< bool >(val2);
7965 {
7966 PyThreadState* __tstate = wxPyBeginAllowThreads();
7967 (arg1)->SetAltDown(arg2);
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7979 PyObject *resultobj = 0;
7980 wxMouseState *arg1 = (wxMouseState *) 0 ;
7981 bool arg2 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 bool val2 ;
7985 int ecode2 = 0 ;
7986 PyObject * obj0 = 0 ;
7987 PyObject * obj1 = 0 ;
7988 char * kwnames[] = {
7989 (char *) "self",(char *) "down", NULL
7990 };
7991
7992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7996 }
7997 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7999 if (!SWIG_IsOK(ecode2)) {
8000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8001 }
8002 arg2 = static_cast< bool >(val2);
8003 {
8004 PyThreadState* __tstate = wxPyBeginAllowThreads();
8005 (arg1)->SetMetaDown(arg2);
8006 wxPyEndAllowThreads(__tstate);
8007 if (PyErr_Occurred()) SWIG_fail;
8008 }
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *obj;
8018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8019 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8020 return SWIG_Py_Void();
8021 }
8022
8023 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 return SWIG_Python_InitShadowInstance(args);
8025 }
8026
8027 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8028 PyObject *resultobj = 0;
8029 wxMouseState result;
8030
8031 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8032 {
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 result = wxGetMouseState();
8035 wxPyEndAllowThreads(__tstate);
8036 if (PyErr_Occurred()) SWIG_fail;
8037 }
8038 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8039 return resultobj;
8040 fail:
8041 return NULL;
8042 }
8043
8044
8045 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8046 PyObject *resultobj = 0;
8047
8048 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8049 {
8050 if (!wxPyCheckForApp()) SWIG_fail;
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 wxWakeUpMainThread();
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 resultobj = SWIG_Py_Void();
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8064 PyObject *resultobj = 0;
8065
8066 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8067 {
8068 if (!wxPyCheckForApp()) SWIG_fail;
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 wxMutexGuiEnter();
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_Py_Void();
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8082 PyObject *resultobj = 0;
8083
8084 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8085 {
8086 if (!wxPyCheckForApp()) SWIG_fail;
8087 PyThreadState* __tstate = wxPyBeginAllowThreads();
8088 wxMutexGuiLeave();
8089 wxPyEndAllowThreads(__tstate);
8090 if (PyErr_Occurred()) SWIG_fail;
8091 }
8092 resultobj = SWIG_Py_Void();
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8100 PyObject *resultobj = 0;
8101 wxMutexGuiLocker *result = 0 ;
8102
8103 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8104 {
8105 if (!wxPyCheckForApp()) SWIG_fail;
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8112 return resultobj;
8113 fail:
8114 return NULL;
8115 }
8116
8117
8118 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8119 PyObject *resultobj = 0;
8120 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8121 void *argp1 = 0 ;
8122 int res1 = 0 ;
8123 PyObject *swig_obj[1] ;
8124
8125 if (!args) SWIG_fail;
8126 swig_obj[0] = args;
8127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8128 if (!SWIG_IsOK(res1)) {
8129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8130 }
8131 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 delete arg1;
8135
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *obj;
8148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8149 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8150 return SWIG_Py_Void();
8151 }
8152
8153 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8154 return SWIG_Python_InitShadowInstance(args);
8155 }
8156
8157 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8158 PyObject *resultobj = 0;
8159 bool result;
8160
8161 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 result = (bool)wxThread_IsMain();
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 {
8169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8170 }
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8178 PyObject *resultobj = 0;
8179 wxString *arg1 = 0 ;
8180 wxToolTip *result = 0 ;
8181 bool temp1 = false ;
8182 PyObject * obj0 = 0 ;
8183 char * kwnames[] = {
8184 (char *) "tip", NULL
8185 };
8186
8187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8188 {
8189 arg1 = wxString_in_helper(obj0);
8190 if (arg1 == NULL) SWIG_fail;
8191 temp1 = true;
8192 }
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8201 {
8202 if (temp1)
8203 delete arg1;
8204 }
8205 return resultobj;
8206 fail:
8207 {
8208 if (temp1)
8209 delete arg1;
8210 }
8211 return NULL;
8212 }
8213
8214
8215 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8216 PyObject *resultobj = 0;
8217 wxToolTip *arg1 = (wxToolTip *) 0 ;
8218 void *argp1 = 0 ;
8219 int res1 = 0 ;
8220 PyObject *swig_obj[1] ;
8221
8222 if (!args) SWIG_fail;
8223 swig_obj[0] = args;
8224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8225 if (!SWIG_IsOK(res1)) {
8226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8227 }
8228 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8229 {
8230 PyThreadState* __tstate = wxPyBeginAllowThreads();
8231 delete arg1;
8232
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_Py_Void();
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj = 0;
8245 wxToolTip *arg1 = (wxToolTip *) 0 ;
8246 wxString *arg2 = 0 ;
8247 void *argp1 = 0 ;
8248 int res1 = 0 ;
8249 bool temp2 = false ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "self",(char *) "tip", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8260 }
8261 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8262 {
8263 arg2 = wxString_in_helper(obj1);
8264 if (arg2 == NULL) SWIG_fail;
8265 temp2 = true;
8266 }
8267 {
8268 PyThreadState* __tstate = wxPyBeginAllowThreads();
8269 (arg1)->SetTip((wxString const &)*arg2);
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_Py_Void();
8274 {
8275 if (temp2)
8276 delete arg2;
8277 }
8278 return resultobj;
8279 fail:
8280 {
8281 if (temp2)
8282 delete arg2;
8283 }
8284 return NULL;
8285 }
8286
8287
8288 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8289 PyObject *resultobj = 0;
8290 wxToolTip *arg1 = (wxToolTip *) 0 ;
8291 wxString result;
8292 void *argp1 = 0 ;
8293 int res1 = 0 ;
8294 PyObject *swig_obj[1] ;
8295
8296 if (!args) SWIG_fail;
8297 swig_obj[0] = args;
8298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8299 if (!SWIG_IsOK(res1)) {
8300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8301 }
8302 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8303 {
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 result = (arg1)->GetTip();
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 {
8310 #if wxUSE_UNICODE
8311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8312 #else
8313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8314 #endif
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8323 PyObject *resultobj = 0;
8324 wxToolTip *arg1 = (wxToolTip *) 0 ;
8325 wxWindow *result = 0 ;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 PyObject *swig_obj[1] ;
8329
8330 if (!args) SWIG_fail;
8331 swig_obj[0] = args;
8332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8333 if (!SWIG_IsOK(res1)) {
8334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8335 }
8336 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (wxWindow *)(arg1)->GetWindow();
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 {
8344 resultobj = wxPyMake_wxObject(result, 0);
8345 }
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 bool arg1 ;
8355 bool val1 ;
8356 int ecode1 = 0 ;
8357 PyObject * obj0 = 0 ;
8358 char * kwnames[] = {
8359 (char *) "flag", NULL
8360 };
8361
8362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8363 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8364 if (!SWIG_IsOK(ecode1)) {
8365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8366 }
8367 arg1 = static_cast< bool >(val1);
8368 {
8369 PyThreadState* __tstate = wxPyBeginAllowThreads();
8370 wxToolTip::Enable(arg1);
8371 wxPyEndAllowThreads(__tstate);
8372 if (PyErr_Occurred()) SWIG_fail;
8373 }
8374 resultobj = SWIG_Py_Void();
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj = 0;
8383 long arg1 ;
8384 long val1 ;
8385 int ecode1 = 0 ;
8386 PyObject * obj0 = 0 ;
8387 char * kwnames[] = {
8388 (char *) "milliseconds", NULL
8389 };
8390
8391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8392 ecode1 = SWIG_AsVal_long(obj0, &val1);
8393 if (!SWIG_IsOK(ecode1)) {
8394 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8395 }
8396 arg1 = static_cast< long >(val1);
8397 {
8398 PyThreadState* __tstate = wxPyBeginAllowThreads();
8399 wxToolTip::SetDelay(arg1);
8400 wxPyEndAllowThreads(__tstate);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_Py_Void();
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *obj;
8412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8413 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8414 return SWIG_Py_Void();
8415 }
8416
8417 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8418 return SWIG_Python_InitShadowInstance(args);
8419 }
8420
8421 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8422 PyObject *resultobj = 0;
8423 wxWindow *arg1 = (wxWindow *) 0 ;
8424 wxSize *arg2 = 0 ;
8425 wxCaret *result = 0 ;
8426 void *argp1 = 0 ;
8427 int res1 = 0 ;
8428 wxSize temp2 ;
8429 PyObject * obj0 = 0 ;
8430 PyObject * obj1 = 0 ;
8431 char * kwnames[] = {
8432 (char *) "window",(char *) "size", NULL
8433 };
8434
8435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8437 if (!SWIG_IsOK(res1)) {
8438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8439 }
8440 arg1 = reinterpret_cast< wxWindow * >(argp1);
8441 {
8442 arg2 = &temp2;
8443 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8444 }
8445 {
8446 if (!wxPyCheckForApp()) SWIG_fail;
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8453 return resultobj;
8454 fail:
8455 return NULL;
8456 }
8457
8458
8459 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8460 PyObject *resultobj = 0;
8461 wxCaret *arg1 = (wxCaret *) 0 ;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 PyObject *swig_obj[1] ;
8465
8466 if (!args) SWIG_fail;
8467 swig_obj[0] = args;
8468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8469 if (!SWIG_IsOK(res1)) {
8470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8471 }
8472 arg1 = reinterpret_cast< wxCaret * >(argp1);
8473 {
8474 PyThreadState* __tstate = wxPyBeginAllowThreads();
8475 delete arg1;
8476
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_Py_Void();
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxCaret *arg1 = (wxCaret *) 0 ;
8490 void *argp1 = 0 ;
8491 int res1 = 0 ;
8492 PyObject *swig_obj[1] ;
8493
8494 if (!args) SWIG_fail;
8495 swig_obj[0] = args;
8496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8499 }
8500 arg1 = reinterpret_cast< wxCaret * >(argp1);
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 wxCaret_Destroy(arg1);
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_Py_Void();
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8515 PyObject *resultobj = 0;
8516 wxCaret *arg1 = (wxCaret *) 0 ;
8517 bool result;
8518 void *argp1 = 0 ;
8519 int res1 = 0 ;
8520 PyObject *swig_obj[1] ;
8521
8522 if (!args) SWIG_fail;
8523 swig_obj[0] = args;
8524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8525 if (!SWIG_IsOK(res1)) {
8526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8527 }
8528 arg1 = reinterpret_cast< wxCaret * >(argp1);
8529 {
8530 PyThreadState* __tstate = wxPyBeginAllowThreads();
8531 result = (bool)(arg1)->IsOk();
8532 wxPyEndAllowThreads(__tstate);
8533 if (PyErr_Occurred()) SWIG_fail;
8534 }
8535 {
8536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8537 }
8538 return resultobj;
8539 fail:
8540 return NULL;
8541 }
8542
8543
8544 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8545 PyObject *resultobj = 0;
8546 wxCaret *arg1 = (wxCaret *) 0 ;
8547 bool result;
8548 void *argp1 = 0 ;
8549 int res1 = 0 ;
8550 PyObject *swig_obj[1] ;
8551
8552 if (!args) SWIG_fail;
8553 swig_obj[0] = args;
8554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8557 }
8558 arg1 = reinterpret_cast< wxCaret * >(argp1);
8559 {
8560 PyThreadState* __tstate = wxPyBeginAllowThreads();
8561 result = (bool)(arg1)->IsVisible();
8562 wxPyEndAllowThreads(__tstate);
8563 if (PyErr_Occurred()) SWIG_fail;
8564 }
8565 {
8566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8567 }
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8575 PyObject *resultobj = 0;
8576 wxCaret *arg1 = (wxCaret *) 0 ;
8577 wxPoint result;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 PyObject *swig_obj[1] ;
8581
8582 if (!args) SWIG_fail;
8583 swig_obj[0] = args;
8584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8585 if (!SWIG_IsOK(res1)) {
8586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8587 }
8588 arg1 = reinterpret_cast< wxCaret * >(argp1);
8589 {
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 result = (arg1)->GetPosition();
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8596 return resultobj;
8597 fail:
8598 return NULL;
8599 }
8600
8601
8602 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8603 PyObject *resultobj = 0;
8604 wxCaret *arg1 = (wxCaret *) 0 ;
8605 int *arg2 = (int *) 0 ;
8606 int *arg3 = (int *) 0 ;
8607 void *argp1 = 0 ;
8608 int res1 = 0 ;
8609 int temp2 ;
8610 int res2 = SWIG_TMPOBJ ;
8611 int temp3 ;
8612 int res3 = SWIG_TMPOBJ ;
8613 PyObject *swig_obj[1] ;
8614
8615 arg2 = &temp2;
8616 arg3 = &temp3;
8617 if (!args) SWIG_fail;
8618 swig_obj[0] = args;
8619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8620 if (!SWIG_IsOK(res1)) {
8621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8622 }
8623 arg1 = reinterpret_cast< wxCaret * >(argp1);
8624 {
8625 PyThreadState* __tstate = wxPyBeginAllowThreads();
8626 (arg1)->GetPosition(arg2,arg3);
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 resultobj = SWIG_Py_Void();
8631 if (SWIG_IsTmpObj(res2)) {
8632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8633 } else {
8634 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8636 }
8637 if (SWIG_IsTmpObj(res3)) {
8638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8639 } else {
8640 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8642 }
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8650 PyObject *resultobj = 0;
8651 wxCaret *arg1 = (wxCaret *) 0 ;
8652 wxSize result;
8653 void *argp1 = 0 ;
8654 int res1 = 0 ;
8655 PyObject *swig_obj[1] ;
8656
8657 if (!args) SWIG_fail;
8658 swig_obj[0] = args;
8659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8660 if (!SWIG_IsOK(res1)) {
8661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8662 }
8663 arg1 = reinterpret_cast< wxCaret * >(argp1);
8664 {
8665 PyThreadState* __tstate = wxPyBeginAllowThreads();
8666 result = (arg1)->GetSize();
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8671 return resultobj;
8672 fail:
8673 return NULL;
8674 }
8675
8676
8677 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678 PyObject *resultobj = 0;
8679 wxCaret *arg1 = (wxCaret *) 0 ;
8680 int *arg2 = (int *) 0 ;
8681 int *arg3 = (int *) 0 ;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 int temp2 ;
8685 int res2 = SWIG_TMPOBJ ;
8686 int temp3 ;
8687 int res3 = SWIG_TMPOBJ ;
8688 PyObject *swig_obj[1] ;
8689
8690 arg2 = &temp2;
8691 arg3 = &temp3;
8692 if (!args) SWIG_fail;
8693 swig_obj[0] = args;
8694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8697 }
8698 arg1 = reinterpret_cast< wxCaret * >(argp1);
8699 {
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 (arg1)->GetSize(arg2,arg3);
8702 wxPyEndAllowThreads(__tstate);
8703 if (PyErr_Occurred()) SWIG_fail;
8704 }
8705 resultobj = SWIG_Py_Void();
8706 if (SWIG_IsTmpObj(res2)) {
8707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8708 } else {
8709 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8711 }
8712 if (SWIG_IsTmpObj(res3)) {
8713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8714 } else {
8715 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8717 }
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8725 PyObject *resultobj = 0;
8726 wxCaret *arg1 = (wxCaret *) 0 ;
8727 wxWindow *result = 0 ;
8728 void *argp1 = 0 ;
8729 int res1 = 0 ;
8730 PyObject *swig_obj[1] ;
8731
8732 if (!args) SWIG_fail;
8733 swig_obj[0] = args;
8734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8735 if (!SWIG_IsOK(res1)) {
8736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8737 }
8738 arg1 = reinterpret_cast< wxCaret * >(argp1);
8739 {
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 result = (wxWindow *)(arg1)->GetWindow();
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 {
8746 resultobj = wxPyMake_wxObject(result, 0);
8747 }
8748 return resultobj;
8749 fail:
8750 return NULL;
8751 }
8752
8753
8754 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj = 0;
8756 wxCaret *arg1 = (wxCaret *) 0 ;
8757 int arg2 ;
8758 int arg3 ;
8759 void *argp1 = 0 ;
8760 int res1 = 0 ;
8761 int val2 ;
8762 int ecode2 = 0 ;
8763 int val3 ;
8764 int ecode3 = 0 ;
8765 PyObject * obj0 = 0 ;
8766 PyObject * obj1 = 0 ;
8767 PyObject * obj2 = 0 ;
8768 char * kwnames[] = {
8769 (char *) "self",(char *) "x",(char *) "y", NULL
8770 };
8771
8772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8776 }
8777 arg1 = reinterpret_cast< wxCaret * >(argp1);
8778 ecode2 = SWIG_AsVal_int(obj1, &val2);
8779 if (!SWIG_IsOK(ecode2)) {
8780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8781 }
8782 arg2 = static_cast< int >(val2);
8783 ecode3 = SWIG_AsVal_int(obj2, &val3);
8784 if (!SWIG_IsOK(ecode3)) {
8785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8786 }
8787 arg3 = static_cast< int >(val3);
8788 {
8789 PyThreadState* __tstate = wxPyBeginAllowThreads();
8790 (arg1)->Move(arg2,arg3);
8791 wxPyEndAllowThreads(__tstate);
8792 if (PyErr_Occurred()) SWIG_fail;
8793 }
8794 resultobj = SWIG_Py_Void();
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8802 PyObject *resultobj = 0;
8803 wxCaret *arg1 = (wxCaret *) 0 ;
8804 wxPoint *arg2 = 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 wxPoint temp2 ;
8808 PyObject * obj0 = 0 ;
8809 PyObject * obj1 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "pt", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8818 }
8819 arg1 = reinterpret_cast< wxCaret * >(argp1);
8820 {
8821 arg2 = &temp2;
8822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8823 }
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 (arg1)->Move((wxPoint const &)*arg2);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_Py_Void();
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj = 0;
8839 wxCaret *arg1 = (wxCaret *) 0 ;
8840 int arg2 ;
8841 int arg3 ;
8842 void *argp1 = 0 ;
8843 int res1 = 0 ;
8844 int val2 ;
8845 int ecode2 = 0 ;
8846 int val3 ;
8847 int ecode3 = 0 ;
8848 PyObject * obj0 = 0 ;
8849 PyObject * obj1 = 0 ;
8850 PyObject * obj2 = 0 ;
8851 char * kwnames[] = {
8852 (char *) "self",(char *) "width",(char *) "height", NULL
8853 };
8854
8855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8857 if (!SWIG_IsOK(res1)) {
8858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8859 }
8860 arg1 = reinterpret_cast< wxCaret * >(argp1);
8861 ecode2 = SWIG_AsVal_int(obj1, &val2);
8862 if (!SWIG_IsOK(ecode2)) {
8863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8864 }
8865 arg2 = static_cast< int >(val2);
8866 ecode3 = SWIG_AsVal_int(obj2, &val3);
8867 if (!SWIG_IsOK(ecode3)) {
8868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8869 }
8870 arg3 = static_cast< int >(val3);
8871 {
8872 PyThreadState* __tstate = wxPyBeginAllowThreads();
8873 (arg1)->SetSize(arg2,arg3);
8874 wxPyEndAllowThreads(__tstate);
8875 if (PyErr_Occurred()) SWIG_fail;
8876 }
8877 resultobj = SWIG_Py_Void();
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj = 0;
8886 wxCaret *arg1 = (wxCaret *) 0 ;
8887 wxSize *arg2 = 0 ;
8888 void *argp1 = 0 ;
8889 int res1 = 0 ;
8890 wxSize temp2 ;
8891 PyObject * obj0 = 0 ;
8892 PyObject * obj1 = 0 ;
8893 char * kwnames[] = {
8894 (char *) "self",(char *) "size", NULL
8895 };
8896
8897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8899 if (!SWIG_IsOK(res1)) {
8900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8901 }
8902 arg1 = reinterpret_cast< wxCaret * >(argp1);
8903 {
8904 arg2 = &temp2;
8905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8906 }
8907 {
8908 PyThreadState* __tstate = wxPyBeginAllowThreads();
8909 (arg1)->SetSize((wxSize const &)*arg2);
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 resultobj = SWIG_Py_Void();
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8921 PyObject *resultobj = 0;
8922 wxCaret *arg1 = (wxCaret *) 0 ;
8923 int arg2 = (int) true ;
8924 void *argp1 = 0 ;
8925 int res1 = 0 ;
8926 int val2 ;
8927 int ecode2 = 0 ;
8928 PyObject * obj0 = 0 ;
8929 PyObject * obj1 = 0 ;
8930 char * kwnames[] = {
8931 (char *) "self",(char *) "show", NULL
8932 };
8933
8934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8938 }
8939 arg1 = reinterpret_cast< wxCaret * >(argp1);
8940 if (obj1) {
8941 ecode2 = SWIG_AsVal_int(obj1, &val2);
8942 if (!SWIG_IsOK(ecode2)) {
8943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8944 }
8945 arg2 = static_cast< int >(val2);
8946 }
8947 {
8948 PyThreadState* __tstate = wxPyBeginAllowThreads();
8949 (arg1)->Show(arg2);
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 *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8961 PyObject *resultobj = 0;
8962 wxCaret *arg1 = (wxCaret *) 0 ;
8963 void *argp1 = 0 ;
8964 int res1 = 0 ;
8965 PyObject *swig_obj[1] ;
8966
8967 if (!args) SWIG_fail;
8968 swig_obj[0] = args;
8969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8970 if (!SWIG_IsOK(res1)) {
8971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8972 }
8973 arg1 = reinterpret_cast< wxCaret * >(argp1);
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 (arg1)->Hide();
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 resultobj = SWIG_Py_Void();
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8988 PyObject *resultobj = 0;
8989 int result;
8990
8991 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8992 {
8993 PyThreadState* __tstate = wxPyBeginAllowThreads();
8994 result = (int)wxCaret::GetBlinkTime();
8995 wxPyEndAllowThreads(__tstate);
8996 if (PyErr_Occurred()) SWIG_fail;
8997 }
8998 resultobj = SWIG_From_int(static_cast< int >(result));
8999 return resultobj;
9000 fail:
9001 return NULL;
9002 }
9003
9004
9005 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9006 PyObject *resultobj = 0;
9007 int arg1 ;
9008 int val1 ;
9009 int ecode1 = 0 ;
9010 PyObject * obj0 = 0 ;
9011 char * kwnames[] = {
9012 (char *) "milliseconds", NULL
9013 };
9014
9015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9016 ecode1 = SWIG_AsVal_int(obj0, &val1);
9017 if (!SWIG_IsOK(ecode1)) {
9018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9019 }
9020 arg1 = static_cast< int >(val1);
9021 {
9022 PyThreadState* __tstate = wxPyBeginAllowThreads();
9023 wxCaret::SetBlinkTime(arg1);
9024 wxPyEndAllowThreads(__tstate);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 resultobj = SWIG_Py_Void();
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9035 PyObject *obj;
9036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9037 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9038 return SWIG_Py_Void();
9039 }
9040
9041 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9042 return SWIG_Python_InitShadowInstance(args);
9043 }
9044
9045 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj = 0;
9047 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9048 wxBusyCursor *result = 0 ;
9049 void *argp1 = 0 ;
9050 int res1 = 0 ;
9051 PyObject * obj0 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "cursor", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9057 if (obj0) {
9058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9061 }
9062 arg1 = reinterpret_cast< wxCursor * >(argp1);
9063 }
9064 {
9065 if (!wxPyCheckForApp()) SWIG_fail;
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9068 wxPyEndAllowThreads(__tstate);
9069 if (PyErr_Occurred()) SWIG_fail;
9070 }
9071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9072 return resultobj;
9073 fail:
9074 return NULL;
9075 }
9076
9077
9078 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9079 PyObject *resultobj = 0;
9080 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9081 void *argp1 = 0 ;
9082 int res1 = 0 ;
9083 PyObject *swig_obj[1] ;
9084
9085 if (!args) SWIG_fail;
9086 swig_obj[0] = args;
9087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9088 if (!SWIG_IsOK(res1)) {
9089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9090 }
9091 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9092 {
9093 PyThreadState* __tstate = wxPyBeginAllowThreads();
9094 delete arg1;
9095
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 *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9107 PyObject *obj;
9108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9109 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9110 return SWIG_Py_Void();
9111 }
9112
9113 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9114 return SWIG_Python_InitShadowInstance(args);
9115 }
9116
9117 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj = 0;
9119 wxWindow *arg1 = (wxWindow *) NULL ;
9120 wxWindowDisabler *result = 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 PyObject * obj0 = 0 ;
9124 char * kwnames[] = {
9125 (char *) "winToSkip", NULL
9126 };
9127
9128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9129 if (obj0) {
9130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9131 if (!SWIG_IsOK(res1)) {
9132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9133 }
9134 arg1 = reinterpret_cast< wxWindow * >(argp1);
9135 }
9136 {
9137 if (!wxPyCheckForApp()) SWIG_fail;
9138 PyThreadState* __tstate = wxPyBeginAllowThreads();
9139 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9140 wxPyEndAllowThreads(__tstate);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9151 PyObject *resultobj = 0;
9152 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9153 void *argp1 = 0 ;
9154 int res1 = 0 ;
9155 PyObject *swig_obj[1] ;
9156
9157 if (!args) SWIG_fail;
9158 swig_obj[0] = args;
9159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9162 }
9163 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9164 {
9165 PyThreadState* __tstate = wxPyBeginAllowThreads();
9166 delete arg1;
9167
9168 wxPyEndAllowThreads(__tstate);
9169 if (PyErr_Occurred()) SWIG_fail;
9170 }
9171 resultobj = SWIG_Py_Void();
9172 return resultobj;
9173 fail:
9174 return NULL;
9175 }
9176
9177
9178 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 PyObject *obj;
9180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9181 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9182 return SWIG_Py_Void();
9183 }
9184
9185 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9186 return SWIG_Python_InitShadowInstance(args);
9187 }
9188
9189 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9190 PyObject *resultobj = 0;
9191 wxString *arg1 = 0 ;
9192 wxBusyInfo *result = 0 ;
9193 bool temp1 = false ;
9194 PyObject * obj0 = 0 ;
9195 char * kwnames[] = {
9196 (char *) "message", NULL
9197 };
9198
9199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9200 {
9201 arg1 = wxString_in_helper(obj0);
9202 if (arg1 == NULL) SWIG_fail;
9203 temp1 = true;
9204 }
9205 {
9206 if (!wxPyCheckForApp()) SWIG_fail;
9207 PyThreadState* __tstate = wxPyBeginAllowThreads();
9208 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9209 wxPyEndAllowThreads(__tstate);
9210 if (PyErr_Occurred()) SWIG_fail;
9211 }
9212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9213 {
9214 if (temp1)
9215 delete arg1;
9216 }
9217 return resultobj;
9218 fail:
9219 {
9220 if (temp1)
9221 delete arg1;
9222 }
9223 return NULL;
9224 }
9225
9226
9227 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9228 PyObject *resultobj = 0;
9229 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9239 }
9240 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 delete arg1;
9244
9245 wxPyEndAllowThreads(__tstate);
9246 if (PyErr_Occurred()) SWIG_fail;
9247 }
9248 resultobj = SWIG_Py_Void();
9249 return resultobj;
9250 fail:
9251 return NULL;
9252 }
9253
9254
9255 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9256 PyObject *obj;
9257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9258 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9259 return SWIG_Py_Void();
9260 }
9261
9262 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 return SWIG_Python_InitShadowInstance(args);
9264 }
9265
9266 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9267 PyObject *resultobj = 0;
9268 wxStopWatch *result = 0 ;
9269
9270 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (wxStopWatch *)new wxStopWatch();
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj = 0;
9286 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9287 long arg2 = (long) 0 ;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 long val2 ;
9291 int ecode2 = 0 ;
9292 PyObject * obj0 = 0 ;
9293 PyObject * obj1 = 0 ;
9294 char * kwnames[] = {
9295 (char *) "self",(char *) "t0", NULL
9296 };
9297
9298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9300 if (!SWIG_IsOK(res1)) {
9301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9302 }
9303 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9304 if (obj1) {
9305 ecode2 = SWIG_AsVal_long(obj1, &val2);
9306 if (!SWIG_IsOK(ecode2)) {
9307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9308 }
9309 arg2 = static_cast< long >(val2);
9310 }
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 (arg1)->Start(arg2);
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_Py_Void();
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9325 PyObject *resultobj = 0;
9326 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9327 void *argp1 = 0 ;
9328 int res1 = 0 ;
9329 PyObject *swig_obj[1] ;
9330
9331 if (!args) SWIG_fail;
9332 swig_obj[0] = args;
9333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9334 if (!SWIG_IsOK(res1)) {
9335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9336 }
9337 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9338 {
9339 PyThreadState* __tstate = wxPyBeginAllowThreads();
9340 (arg1)->Pause();
9341 wxPyEndAllowThreads(__tstate);
9342 if (PyErr_Occurred()) SWIG_fail;
9343 }
9344 resultobj = SWIG_Py_Void();
9345 return resultobj;
9346 fail:
9347 return NULL;
9348 }
9349
9350
9351 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9352 PyObject *resultobj = 0;
9353 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9354 void *argp1 = 0 ;
9355 int res1 = 0 ;
9356 PyObject *swig_obj[1] ;
9357
9358 if (!args) SWIG_fail;
9359 swig_obj[0] = args;
9360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9361 if (!SWIG_IsOK(res1)) {
9362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9363 }
9364 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9365 {
9366 PyThreadState* __tstate = wxPyBeginAllowThreads();
9367 (arg1)->Resume();
9368 wxPyEndAllowThreads(__tstate);
9369 if (PyErr_Occurred()) SWIG_fail;
9370 }
9371 resultobj = SWIG_Py_Void();
9372 return resultobj;
9373 fail:
9374 return NULL;
9375 }
9376
9377
9378 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9379 PyObject *resultobj = 0;
9380 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9381 long result;
9382 void *argp1 = 0 ;
9383 int res1 = 0 ;
9384 PyObject *swig_obj[1] ;
9385
9386 if (!args) SWIG_fail;
9387 swig_obj[0] = args;
9388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9389 if (!SWIG_IsOK(res1)) {
9390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9391 }
9392 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9393 {
9394 PyThreadState* __tstate = wxPyBeginAllowThreads();
9395 result = (long)((wxStopWatch const *)arg1)->Time();
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 resultobj = SWIG_From_long(static_cast< long >(result));
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9407 PyObject *obj;
9408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9409 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9410 return SWIG_Py_Void();
9411 }
9412
9413 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9414 return SWIG_Python_InitShadowInstance(args);
9415 }
9416
9417 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9418 PyObject *resultobj = 0;
9419 int arg1 = (int) 9 ;
9420 int arg2 = (int) wxID_FILE1 ;
9421 wxFileHistory *result = 0 ;
9422 int val1 ;
9423 int ecode1 = 0 ;
9424 int val2 ;
9425 int ecode2 = 0 ;
9426 PyObject * obj0 = 0 ;
9427 PyObject * obj1 = 0 ;
9428 char * kwnames[] = {
9429 (char *) "maxFiles",(char *) "idBase", NULL
9430 };
9431
9432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9433 if (obj0) {
9434 ecode1 = SWIG_AsVal_int(obj0, &val1);
9435 if (!SWIG_IsOK(ecode1)) {
9436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9437 }
9438 arg1 = static_cast< int >(val1);
9439 }
9440 if (obj1) {
9441 ecode2 = SWIG_AsVal_int(obj1, &val2);
9442 if (!SWIG_IsOK(ecode2)) {
9443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9444 }
9445 arg2 = static_cast< int >(val2);
9446 }
9447 {
9448 PyThreadState* __tstate = wxPyBeginAllowThreads();
9449 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9454 return resultobj;
9455 fail:
9456 return NULL;
9457 }
9458
9459
9460 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9461 PyObject *resultobj = 0;
9462 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9463 void *argp1 = 0 ;
9464 int res1 = 0 ;
9465 PyObject *swig_obj[1] ;
9466
9467 if (!args) SWIG_fail;
9468 swig_obj[0] = args;
9469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9470 if (!SWIG_IsOK(res1)) {
9471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9472 }
9473 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 delete arg1;
9477
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_Py_Void();
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9491 wxString *arg2 = 0 ;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 bool temp2 = false ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 char * kwnames[] = {
9498 (char *) "self",(char *) "file", NULL
9499 };
9500
9501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9503 if (!SWIG_IsOK(res1)) {
9504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9505 }
9506 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9507 {
9508 arg2 = wxString_in_helper(obj1);
9509 if (arg2 == NULL) SWIG_fail;
9510 temp2 = true;
9511 }
9512 {
9513 PyThreadState* __tstate = wxPyBeginAllowThreads();
9514 (arg1)->AddFileToHistory((wxString const &)*arg2);
9515 wxPyEndAllowThreads(__tstate);
9516 if (PyErr_Occurred()) SWIG_fail;
9517 }
9518 resultobj = SWIG_Py_Void();
9519 {
9520 if (temp2)
9521 delete arg2;
9522 }
9523 return resultobj;
9524 fail:
9525 {
9526 if (temp2)
9527 delete arg2;
9528 }
9529 return NULL;
9530 }
9531
9532
9533 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9534 PyObject *resultobj = 0;
9535 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9536 int arg2 ;
9537 void *argp1 = 0 ;
9538 int res1 = 0 ;
9539 int val2 ;
9540 int ecode2 = 0 ;
9541 PyObject * obj0 = 0 ;
9542 PyObject * obj1 = 0 ;
9543 char * kwnames[] = {
9544 (char *) "self",(char *) "i", NULL
9545 };
9546
9547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9549 if (!SWIG_IsOK(res1)) {
9550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9551 }
9552 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9553 ecode2 = SWIG_AsVal_int(obj1, &val2);
9554 if (!SWIG_IsOK(ecode2)) {
9555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9556 }
9557 arg2 = static_cast< int >(val2);
9558 {
9559 PyThreadState* __tstate = wxPyBeginAllowThreads();
9560 (arg1)->RemoveFileFromHistory(arg2);
9561 wxPyEndAllowThreads(__tstate);
9562 if (PyErr_Occurred()) SWIG_fail;
9563 }
9564 resultobj = SWIG_Py_Void();
9565 return resultobj;
9566 fail:
9567 return NULL;
9568 }
9569
9570
9571 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9572 PyObject *resultobj = 0;
9573 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9574 int result;
9575 void *argp1 = 0 ;
9576 int res1 = 0 ;
9577 PyObject *swig_obj[1] ;
9578
9579 if (!args) SWIG_fail;
9580 swig_obj[0] = args;
9581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9582 if (!SWIG_IsOK(res1)) {
9583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9584 }
9585 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9586 {
9587 PyThreadState* __tstate = wxPyBeginAllowThreads();
9588 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9589 wxPyEndAllowThreads(__tstate);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 resultobj = SWIG_From_int(static_cast< int >(result));
9593 return resultobj;
9594 fail:
9595 return NULL;
9596 }
9597
9598
9599 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9600 PyObject *resultobj = 0;
9601 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9602 wxMenu *arg2 = (wxMenu *) 0 ;
9603 void *argp1 = 0 ;
9604 int res1 = 0 ;
9605 void *argp2 = 0 ;
9606 int res2 = 0 ;
9607 PyObject * obj0 = 0 ;
9608 PyObject * obj1 = 0 ;
9609 char * kwnames[] = {
9610 (char *) "self",(char *) "menu", NULL
9611 };
9612
9613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9615 if (!SWIG_IsOK(res1)) {
9616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9617 }
9618 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9620 if (!SWIG_IsOK(res2)) {
9621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9622 }
9623 arg2 = reinterpret_cast< wxMenu * >(argp2);
9624 {
9625 PyThreadState* __tstate = wxPyBeginAllowThreads();
9626 (arg1)->UseMenu(arg2);
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 resultobj = SWIG_Py_Void();
9631 return resultobj;
9632 fail:
9633 return NULL;
9634 }
9635
9636
9637 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9638 PyObject *resultobj = 0;
9639 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9640 wxMenu *arg2 = (wxMenu *) 0 ;
9641 void *argp1 = 0 ;
9642 int res1 = 0 ;
9643 void *argp2 = 0 ;
9644 int res2 = 0 ;
9645 PyObject * obj0 = 0 ;
9646 PyObject * obj1 = 0 ;
9647 char * kwnames[] = {
9648 (char *) "self",(char *) "menu", NULL
9649 };
9650
9651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9653 if (!SWIG_IsOK(res1)) {
9654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9655 }
9656 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9658 if (!SWIG_IsOK(res2)) {
9659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9660 }
9661 arg2 = reinterpret_cast< wxMenu * >(argp2);
9662 {
9663 PyThreadState* __tstate = wxPyBeginAllowThreads();
9664 (arg1)->RemoveMenu(arg2);
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 resultobj = SWIG_Py_Void();
9669 return resultobj;
9670 fail:
9671 return NULL;
9672 }
9673
9674
9675 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9676 PyObject *resultobj = 0;
9677 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9678 wxConfigBase *arg2 = 0 ;
9679 void *argp1 = 0 ;
9680 int res1 = 0 ;
9681 void *argp2 = 0 ;
9682 int res2 = 0 ;
9683 PyObject * obj0 = 0 ;
9684 PyObject * obj1 = 0 ;
9685 char * kwnames[] = {
9686 (char *) "self",(char *) "config", NULL
9687 };
9688
9689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9691 if (!SWIG_IsOK(res1)) {
9692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9693 }
9694 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9696 if (!SWIG_IsOK(res2)) {
9697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9698 }
9699 if (!argp2) {
9700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9701 }
9702 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 (arg1)->Load(*arg2);
9706 wxPyEndAllowThreads(__tstate);
9707 if (PyErr_Occurred()) SWIG_fail;
9708 }
9709 resultobj = SWIG_Py_Void();
9710 return resultobj;
9711 fail:
9712 return NULL;
9713 }
9714
9715
9716 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9717 PyObject *resultobj = 0;
9718 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9719 wxConfigBase *arg2 = 0 ;
9720 void *argp1 = 0 ;
9721 int res1 = 0 ;
9722 void *argp2 = 0 ;
9723 int res2 = 0 ;
9724 PyObject * obj0 = 0 ;
9725 PyObject * obj1 = 0 ;
9726 char * kwnames[] = {
9727 (char *) "self",(char *) "config", NULL
9728 };
9729
9730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9732 if (!SWIG_IsOK(res1)) {
9733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9734 }
9735 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9736 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9737 if (!SWIG_IsOK(res2)) {
9738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9739 }
9740 if (!argp2) {
9741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9742 }
9743 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9744 {
9745 PyThreadState* __tstate = wxPyBeginAllowThreads();
9746 (arg1)->Save(*arg2);
9747 wxPyEndAllowThreads(__tstate);
9748 if (PyErr_Occurred()) SWIG_fail;
9749 }
9750 resultobj = SWIG_Py_Void();
9751 return resultobj;
9752 fail:
9753 return NULL;
9754 }
9755
9756
9757 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9758 PyObject *resultobj = 0;
9759 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9760 void *argp1 = 0 ;
9761 int res1 = 0 ;
9762 PyObject *swig_obj[1] ;
9763
9764 if (!args) SWIG_fail;
9765 swig_obj[0] = args;
9766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9767 if (!SWIG_IsOK(res1)) {
9768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9769 }
9770 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9771 {
9772 PyThreadState* __tstate = wxPyBeginAllowThreads();
9773 (arg1)->AddFilesToMenu();
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 resultobj = SWIG_Py_Void();
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9785 PyObject *resultobj = 0;
9786 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9787 wxMenu *arg2 = (wxMenu *) 0 ;
9788 void *argp1 = 0 ;
9789 int res1 = 0 ;
9790 void *argp2 = 0 ;
9791 int res2 = 0 ;
9792 PyObject * obj0 = 0 ;
9793 PyObject * obj1 = 0 ;
9794 char * kwnames[] = {
9795 (char *) "self",(char *) "menu", NULL
9796 };
9797
9798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9800 if (!SWIG_IsOK(res1)) {
9801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9802 }
9803 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9804 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9805 if (!SWIG_IsOK(res2)) {
9806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9807 }
9808 arg2 = reinterpret_cast< wxMenu * >(argp2);
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 (arg1)->AddFilesToMenu(arg2);
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 resultobj = SWIG_Py_Void();
9816 return resultobj;
9817 fail:
9818 return NULL;
9819 }
9820
9821
9822 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9823 PyObject *resultobj = 0;
9824 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9825 int arg2 ;
9826 wxString result;
9827 void *argp1 = 0 ;
9828 int res1 = 0 ;
9829 int val2 ;
9830 int ecode2 = 0 ;
9831 PyObject * obj0 = 0 ;
9832 PyObject * obj1 = 0 ;
9833 char * kwnames[] = {
9834 (char *) "self",(char *) "i", NULL
9835 };
9836
9837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9839 if (!SWIG_IsOK(res1)) {
9840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9841 }
9842 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9843 ecode2 = SWIG_AsVal_int(obj1, &val2);
9844 if (!SWIG_IsOK(ecode2)) {
9845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9846 }
9847 arg2 = static_cast< int >(val2);
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9851 wxPyEndAllowThreads(__tstate);
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 {
9855 #if wxUSE_UNICODE
9856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9857 #else
9858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9859 #endif
9860 }
9861 return resultobj;
9862 fail:
9863 return NULL;
9864 }
9865
9866
9867 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9868 PyObject *resultobj = 0;
9869 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9870 int result;
9871 void *argp1 = 0 ;
9872 int res1 = 0 ;
9873 PyObject *swig_obj[1] ;
9874
9875 if (!args) SWIG_fail;
9876 swig_obj[0] = args;
9877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9878 if (!SWIG_IsOK(res1)) {
9879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9880 }
9881 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9882 {
9883 PyThreadState* __tstate = wxPyBeginAllowThreads();
9884 result = (int)((wxFileHistory const *)arg1)->GetCount();
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 resultobj = SWIG_From_int(static_cast< int >(result));
9889 return resultobj;
9890 fail:
9891 return NULL;
9892 }
9893
9894
9895 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9896 PyObject *obj;
9897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9898 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9899 return SWIG_Py_Void();
9900 }
9901
9902 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 return SWIG_Python_InitShadowInstance(args);
9904 }
9905
9906 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9907 PyObject *resultobj = 0;
9908 wxString *arg1 = 0 ;
9909 wxString const &arg2_defvalue = wxPyEmptyString ;
9910 wxString *arg2 = (wxString *) &arg2_defvalue ;
9911 wxSingleInstanceChecker *result = 0 ;
9912 bool temp1 = false ;
9913 bool temp2 = false ;
9914 PyObject * obj0 = 0 ;
9915 PyObject * obj1 = 0 ;
9916 char * kwnames[] = {
9917 (char *) "name",(char *) "path", NULL
9918 };
9919
9920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9921 {
9922 arg1 = wxString_in_helper(obj0);
9923 if (arg1 == NULL) SWIG_fail;
9924 temp1 = true;
9925 }
9926 if (obj1) {
9927 {
9928 arg2 = wxString_in_helper(obj1);
9929 if (arg2 == NULL) SWIG_fail;
9930 temp2 = true;
9931 }
9932 }
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9940 {
9941 if (temp1)
9942 delete arg1;
9943 }
9944 {
9945 if (temp2)
9946 delete arg2;
9947 }
9948 return resultobj;
9949 fail:
9950 {
9951 if (temp1)
9952 delete arg1;
9953 }
9954 {
9955 if (temp2)
9956 delete arg2;
9957 }
9958 return NULL;
9959 }
9960
9961
9962 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9963 PyObject *resultobj = 0;
9964 wxSingleInstanceChecker *result = 0 ;
9965
9966 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9967 {
9968 PyThreadState* __tstate = wxPyBeginAllowThreads();
9969 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9970 wxPyEndAllowThreads(__tstate);
9971 if (PyErr_Occurred()) SWIG_fail;
9972 }
9973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9974 return resultobj;
9975 fail:
9976 return NULL;
9977 }
9978
9979
9980 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9981 PyObject *resultobj = 0;
9982 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9983 void *argp1 = 0 ;
9984 int res1 = 0 ;
9985 PyObject *swig_obj[1] ;
9986
9987 if (!args) SWIG_fail;
9988 swig_obj[0] = args;
9989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9992 }
9993 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9994 {
9995 PyThreadState* __tstate = wxPyBeginAllowThreads();
9996 delete arg1;
9997
9998 wxPyEndAllowThreads(__tstate);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_Py_Void();
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10009 PyObject *resultobj = 0;
10010 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10011 wxString *arg2 = 0 ;
10012 wxString const &arg3_defvalue = wxPyEmptyString ;
10013 wxString *arg3 = (wxString *) &arg3_defvalue ;
10014 bool result;
10015 void *argp1 = 0 ;
10016 int res1 = 0 ;
10017 bool temp2 = false ;
10018 bool temp3 = false ;
10019 PyObject * obj0 = 0 ;
10020 PyObject * obj1 = 0 ;
10021 PyObject * obj2 = 0 ;
10022 char * kwnames[] = {
10023 (char *) "self",(char *) "name",(char *) "path", NULL
10024 };
10025
10026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10028 if (!SWIG_IsOK(res1)) {
10029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10030 }
10031 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10032 {
10033 arg2 = wxString_in_helper(obj1);
10034 if (arg2 == NULL) SWIG_fail;
10035 temp2 = true;
10036 }
10037 if (obj2) {
10038 {
10039 arg3 = wxString_in_helper(obj2);
10040 if (arg3 == NULL) SWIG_fail;
10041 temp3 = true;
10042 }
10043 }
10044 {
10045 PyThreadState* __tstate = wxPyBeginAllowThreads();
10046 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10047 wxPyEndAllowThreads(__tstate);
10048 if (PyErr_Occurred()) SWIG_fail;
10049 }
10050 {
10051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10052 }
10053 {
10054 if (temp2)
10055 delete arg2;
10056 }
10057 {
10058 if (temp3)
10059 delete arg3;
10060 }
10061 return resultobj;
10062 fail:
10063 {
10064 if (temp2)
10065 delete arg2;
10066 }
10067 {
10068 if (temp3)
10069 delete arg3;
10070 }
10071 return NULL;
10072 }
10073
10074
10075 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10076 PyObject *resultobj = 0;
10077 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10078 bool result;
10079 void *argp1 = 0 ;
10080 int res1 = 0 ;
10081 PyObject *swig_obj[1] ;
10082
10083 if (!args) SWIG_fail;
10084 swig_obj[0] = args;
10085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10086 if (!SWIG_IsOK(res1)) {
10087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10088 }
10089 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10090 {
10091 PyThreadState* __tstate = wxPyBeginAllowThreads();
10092 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10093 wxPyEndAllowThreads(__tstate);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 {
10097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10098 }
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10106 PyObject *obj;
10107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10108 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10109 return SWIG_Py_Void();
10110 }
10111
10112 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10113 return SWIG_Python_InitShadowInstance(args);
10114 }
10115
10116 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10117 PyObject *resultobj = 0;
10118 wxPlatformInfo *result = 0 ;
10119
10120 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 result = (wxPlatformInfo *)new wxPlatformInfo();
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10128 return resultobj;
10129 fail:
10130 return NULL;
10131 }
10132
10133
10134 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10135 PyObject *resultobj = 0;
10136 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10137 wxPlatformInfo *arg2 = 0 ;
10138 bool result;
10139 void *argp1 = 0 ;
10140 int res1 = 0 ;
10141 void *argp2 = 0 ;
10142 int res2 = 0 ;
10143 PyObject * obj0 = 0 ;
10144 PyObject * obj1 = 0 ;
10145 char * kwnames[] = {
10146 (char *) "self",(char *) "t", NULL
10147 };
10148
10149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10151 if (!SWIG_IsOK(res1)) {
10152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10153 }
10154 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10156 if (!SWIG_IsOK(res2)) {
10157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10158 }
10159 if (!argp2) {
10160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10161 }
10162 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10163 {
10164 PyThreadState* __tstate = wxPyBeginAllowThreads();
10165 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10166 wxPyEndAllowThreads(__tstate);
10167 if (PyErr_Occurred()) SWIG_fail;
10168 }
10169 {
10170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10171 }
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj = 0;
10180 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10181 wxPlatformInfo *arg2 = 0 ;
10182 bool result;
10183 void *argp1 = 0 ;
10184 int res1 = 0 ;
10185 void *argp2 = 0 ;
10186 int res2 = 0 ;
10187 PyObject * obj0 = 0 ;
10188 PyObject * obj1 = 0 ;
10189 char * kwnames[] = {
10190 (char *) "self",(char *) "t", NULL
10191 };
10192
10193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10195 if (!SWIG_IsOK(res1)) {
10196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10197 }
10198 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10199 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10200 if (!SWIG_IsOK(res2)) {
10201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10202 }
10203 if (!argp2) {
10204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10205 }
10206 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10207 {
10208 PyThreadState* __tstate = wxPyBeginAllowThreads();
10209 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10210 wxPyEndAllowThreads(__tstate);
10211 if (PyErr_Occurred()) SWIG_fail;
10212 }
10213 {
10214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10215 }
10216 return resultobj;
10217 fail:
10218 return NULL;
10219 }
10220
10221
10222 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10223 PyObject *resultobj = 0;
10224 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10225 int result;
10226 void *argp1 = 0 ;
10227 int res1 = 0 ;
10228 PyObject *swig_obj[1] ;
10229
10230 if (!args) SWIG_fail;
10231 swig_obj[0] = args;
10232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10233 if (!SWIG_IsOK(res1)) {
10234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10235 }
10236 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10237 {
10238 PyThreadState* __tstate = wxPyBeginAllowThreads();
10239 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10240 wxPyEndAllowThreads(__tstate);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 resultobj = SWIG_From_int(static_cast< int >(result));
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10251 PyObject *resultobj = 0;
10252 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10253 int result;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 PyObject *swig_obj[1] ;
10257
10258 if (!args) SWIG_fail;
10259 swig_obj[0] = args;
10260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10261 if (!SWIG_IsOK(res1)) {
10262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10263 }
10264 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10265 {
10266 PyThreadState* __tstate = wxPyBeginAllowThreads();
10267 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 resultobj = SWIG_From_int(static_cast< int >(result));
10272 return resultobj;
10273 fail:
10274 return NULL;
10275 }
10276
10277
10278 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10279 PyObject *resultobj = 0;
10280 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10281 int arg2 ;
10282 int arg3 ;
10283 bool result;
10284 void *argp1 = 0 ;
10285 int res1 = 0 ;
10286 int val2 ;
10287 int ecode2 = 0 ;
10288 int val3 ;
10289 int ecode3 = 0 ;
10290 PyObject * obj0 = 0 ;
10291 PyObject * obj1 = 0 ;
10292 PyObject * obj2 = 0 ;
10293 char * kwnames[] = {
10294 (char *) "self",(char *) "major",(char *) "minor", NULL
10295 };
10296
10297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10299 if (!SWIG_IsOK(res1)) {
10300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10301 }
10302 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10303 ecode2 = SWIG_AsVal_int(obj1, &val2);
10304 if (!SWIG_IsOK(ecode2)) {
10305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10306 }
10307 arg2 = static_cast< int >(val2);
10308 ecode3 = SWIG_AsVal_int(obj2, &val3);
10309 if (!SWIG_IsOK(ecode3)) {
10310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10311 }
10312 arg3 = static_cast< int >(val3);
10313 {
10314 PyThreadState* __tstate = wxPyBeginAllowThreads();
10315 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 {
10320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10321 }
10322 return resultobj;
10323 fail:
10324 return NULL;
10325 }
10326
10327
10328 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10329 PyObject *resultobj = 0;
10330 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10331 int result;
10332 void *argp1 = 0 ;
10333 int res1 = 0 ;
10334 PyObject *swig_obj[1] ;
10335
10336 if (!args) SWIG_fail;
10337 swig_obj[0] = args;
10338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10339 if (!SWIG_IsOK(res1)) {
10340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10341 }
10342 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10343 {
10344 PyThreadState* __tstate = wxPyBeginAllowThreads();
10345 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10346 wxPyEndAllowThreads(__tstate);
10347 if (PyErr_Occurred()) SWIG_fail;
10348 }
10349 resultobj = SWIG_From_int(static_cast< int >(result));
10350 return resultobj;
10351 fail:
10352 return NULL;
10353 }
10354
10355
10356 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10357 PyObject *resultobj = 0;
10358 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10359 int result;
10360 void *argp1 = 0 ;
10361 int res1 = 0 ;
10362 PyObject *swig_obj[1] ;
10363
10364 if (!args) SWIG_fail;
10365 swig_obj[0] = args;
10366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10367 if (!SWIG_IsOK(res1)) {
10368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10369 }
10370 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 resultobj = SWIG_From_int(static_cast< int >(result));
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj = 0;
10386 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10387 int arg2 ;
10388 int arg3 ;
10389 bool result;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 int val2 ;
10393 int ecode2 = 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 *) "major",(char *) "minor", NULL
10401 };
10402
10403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10405 if (!SWIG_IsOK(res1)) {
10406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10407 }
10408 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10409 ecode2 = SWIG_AsVal_int(obj1, &val2);
10410 if (!SWIG_IsOK(ecode2)) {
10411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10412 }
10413 arg2 = static_cast< int >(val2);
10414 ecode3 = SWIG_AsVal_int(obj2, &val3);
10415 if (!SWIG_IsOK(ecode3)) {
10416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10417 }
10418 arg3 = static_cast< int >(val3);
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10422 wxPyEndAllowThreads(__tstate);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 {
10426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10427 }
10428 return resultobj;
10429 fail:
10430 return NULL;
10431 }
10432
10433
10434 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10435 PyObject *resultobj = 0;
10436 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10437 bool result;
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_wxPlatformInfo, 0 | 0 );
10445 if (!SWIG_IsOK(res1)) {
10446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10447 }
10448 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 {
10456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10457 }
10458 return resultobj;
10459 fail:
10460 return NULL;
10461 }
10462
10463
10464 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10465 PyObject *resultobj = 0;
10466 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10467 wxOperatingSystemId result;
10468 void *argp1 = 0 ;
10469 int res1 = 0 ;
10470 PyObject *swig_obj[1] ;
10471
10472 if (!args) SWIG_fail;
10473 swig_obj[0] = args;
10474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10475 if (!SWIG_IsOK(res1)) {
10476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10477 }
10478 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10479 {
10480 PyThreadState* __tstate = wxPyBeginAllowThreads();
10481 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10482 wxPyEndAllowThreads(__tstate);
10483 if (PyErr_Occurred()) SWIG_fail;
10484 }
10485 resultobj = SWIG_From_int(static_cast< int >(result));
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10493 PyObject *resultobj = 0;
10494 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10495 wxPortId result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 PyObject *swig_obj[1] ;
10499
10500 if (!args) SWIG_fail;
10501 swig_obj[0] = args;
10502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10503 if (!SWIG_IsOK(res1)) {
10504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10505 }
10506 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_From_int(static_cast< int >(result));
10514 return resultobj;
10515 fail:
10516 return NULL;
10517 }
10518
10519
10520 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10521 PyObject *resultobj = 0;
10522 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10523 wxArchitecture result;
10524 void *argp1 = 0 ;
10525 int res1 = 0 ;
10526 PyObject *swig_obj[1] ;
10527
10528 if (!args) SWIG_fail;
10529 swig_obj[0] = args;
10530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10533 }
10534 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10535 {
10536 PyThreadState* __tstate = wxPyBeginAllowThreads();
10537 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10538 wxPyEndAllowThreads(__tstate);
10539 if (PyErr_Occurred()) SWIG_fail;
10540 }
10541 resultobj = SWIG_From_int(static_cast< int >(result));
10542 return resultobj;
10543 fail:
10544 return NULL;
10545 }
10546
10547
10548 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10549 PyObject *resultobj = 0;
10550 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10551 wxEndianness result;
10552 void *argp1 = 0 ;
10553 int res1 = 0 ;
10554 PyObject *swig_obj[1] ;
10555
10556 if (!args) SWIG_fail;
10557 swig_obj[0] = args;
10558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10559 if (!SWIG_IsOK(res1)) {
10560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10561 }
10562 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10563 {
10564 PyThreadState* __tstate = wxPyBeginAllowThreads();
10565 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10566 wxPyEndAllowThreads(__tstate);
10567 if (PyErr_Occurred()) SWIG_fail;
10568 }
10569 resultobj = SWIG_From_int(static_cast< int >(result));
10570 return resultobj;
10571 fail:
10572 return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577 PyObject *resultobj = 0;
10578 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10579 wxString result;
10580 void *argp1 = 0 ;
10581 int res1 = 0 ;
10582 PyObject *swig_obj[1] ;
10583
10584 if (!args) SWIG_fail;
10585 swig_obj[0] = args;
10586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10589 }
10590 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 {
10598 #if wxUSE_UNICODE
10599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10600 #else
10601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10602 #endif
10603 }
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10611 PyObject *resultobj = 0;
10612 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10613 wxString result;
10614 void *argp1 = 0 ;
10615 int res1 = 0 ;
10616 PyObject *swig_obj[1] ;
10617
10618 if (!args) SWIG_fail;
10619 swig_obj[0] = args;
10620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10621 if (!SWIG_IsOK(res1)) {
10622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10623 }
10624 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10628 wxPyEndAllowThreads(__tstate);
10629 if (PyErr_Occurred()) SWIG_fail;
10630 }
10631 {
10632 #if wxUSE_UNICODE
10633 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10634 #else
10635 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10636 #endif
10637 }
10638 return resultobj;
10639 fail:
10640 return NULL;
10641 }
10642
10643
10644 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10645 PyObject *resultobj = 0;
10646 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10647 wxString result;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 PyObject *swig_obj[1] ;
10651
10652 if (!args) SWIG_fail;
10653 swig_obj[0] = args;
10654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10657 }
10658 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10659 {
10660 PyThreadState* __tstate = wxPyBeginAllowThreads();
10661 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10662 wxPyEndAllowThreads(__tstate);
10663 if (PyErr_Occurred()) SWIG_fail;
10664 }
10665 {
10666 #if wxUSE_UNICODE
10667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10668 #else
10669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10670 #endif
10671 }
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10679 PyObject *resultobj = 0;
10680 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10681 wxString result;
10682 void *argp1 = 0 ;
10683 int res1 = 0 ;
10684 PyObject *swig_obj[1] ;
10685
10686 if (!args) SWIG_fail;
10687 swig_obj[0] = args;
10688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10689 if (!SWIG_IsOK(res1)) {
10690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10691 }
10692 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10693 {
10694 PyThreadState* __tstate = wxPyBeginAllowThreads();
10695 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10696 wxPyEndAllowThreads(__tstate);
10697 if (PyErr_Occurred()) SWIG_fail;
10698 }
10699 {
10700 #if wxUSE_UNICODE
10701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10702 #else
10703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10704 #endif
10705 }
10706 return resultobj;
10707 fail:
10708 return NULL;
10709 }
10710
10711
10712 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10713 PyObject *resultobj = 0;
10714 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10715 wxString result;
10716 void *argp1 = 0 ;
10717 int res1 = 0 ;
10718 PyObject *swig_obj[1] ;
10719
10720 if (!args) SWIG_fail;
10721 swig_obj[0] = args;
10722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10723 if (!SWIG_IsOK(res1)) {
10724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10725 }
10726 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10727 {
10728 PyThreadState* __tstate = wxPyBeginAllowThreads();
10729 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10730 wxPyEndAllowThreads(__tstate);
10731 if (PyErr_Occurred()) SWIG_fail;
10732 }
10733 {
10734 #if wxUSE_UNICODE
10735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10736 #else
10737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10738 #endif
10739 }
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10747 PyObject *resultobj = 0;
10748 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10749 wxString result;
10750 void *argp1 = 0 ;
10751 int res1 = 0 ;
10752 PyObject *swig_obj[1] ;
10753
10754 if (!args) SWIG_fail;
10755 swig_obj[0] = args;
10756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10757 if (!SWIG_IsOK(res1)) {
10758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10759 }
10760 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 {
10768 #if wxUSE_UNICODE
10769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10770 #else
10771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10772 #endif
10773 }
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj = 0;
10782 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10783 int arg2 ;
10784 int arg3 ;
10785 void *argp1 = 0 ;
10786 int res1 = 0 ;
10787 int val2 ;
10788 int ecode2 = 0 ;
10789 int val3 ;
10790 int ecode3 = 0 ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 PyObject * obj2 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "self",(char *) "major",(char *) "minor", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10802 }
10803 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10804 ecode2 = SWIG_AsVal_int(obj1, &val2);
10805 if (!SWIG_IsOK(ecode2)) {
10806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10807 }
10808 arg2 = static_cast< int >(val2);
10809 ecode3 = SWIG_AsVal_int(obj2, &val3);
10810 if (!SWIG_IsOK(ecode3)) {
10811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10812 }
10813 arg3 = static_cast< int >(val3);
10814 {
10815 PyThreadState* __tstate = wxPyBeginAllowThreads();
10816 (arg1)->SetOSVersion(arg2,arg3);
10817 wxPyEndAllowThreads(__tstate);
10818 if (PyErr_Occurred()) SWIG_fail;
10819 }
10820 resultobj = SWIG_Py_Void();
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10830 int arg2 ;
10831 int arg3 ;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 int val2 ;
10835 int ecode2 = 0 ;
10836 int val3 ;
10837 int ecode3 = 0 ;
10838 PyObject * obj0 = 0 ;
10839 PyObject * obj1 = 0 ;
10840 PyObject * obj2 = 0 ;
10841 char * kwnames[] = {
10842 (char *) "self",(char *) "major",(char *) "minor", NULL
10843 };
10844
10845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10847 if (!SWIG_IsOK(res1)) {
10848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10849 }
10850 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10851 ecode2 = SWIG_AsVal_int(obj1, &val2);
10852 if (!SWIG_IsOK(ecode2)) {
10853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10854 }
10855 arg2 = static_cast< int >(val2);
10856 ecode3 = SWIG_AsVal_int(obj2, &val3);
10857 if (!SWIG_IsOK(ecode3)) {
10858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10859 }
10860 arg3 = static_cast< int >(val3);
10861 {
10862 PyThreadState* __tstate = wxPyBeginAllowThreads();
10863 (arg1)->SetToolkitVersion(arg2,arg3);
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_Py_Void();
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = 0;
10876 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10877 wxOperatingSystemId arg2 ;
10878 void *argp1 = 0 ;
10879 int res1 = 0 ;
10880 int val2 ;
10881 int ecode2 = 0 ;
10882 PyObject * obj0 = 0 ;
10883 PyObject * obj1 = 0 ;
10884 char * kwnames[] = {
10885 (char *) "self",(char *) "n", NULL
10886 };
10887
10888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10890 if (!SWIG_IsOK(res1)) {
10891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10892 }
10893 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10894 ecode2 = SWIG_AsVal_int(obj1, &val2);
10895 if (!SWIG_IsOK(ecode2)) {
10896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10897 }
10898 arg2 = static_cast< wxOperatingSystemId >(val2);
10899 {
10900 PyThreadState* __tstate = wxPyBeginAllowThreads();
10901 (arg1)->SetOperatingSystemId(arg2);
10902 wxPyEndAllowThreads(__tstate);
10903 if (PyErr_Occurred()) SWIG_fail;
10904 }
10905 resultobj = SWIG_Py_Void();
10906 return resultobj;
10907 fail:
10908 return NULL;
10909 }
10910
10911
10912 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10913 PyObject *resultobj = 0;
10914 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10915 wxPortId arg2 ;
10916 void *argp1 = 0 ;
10917 int res1 = 0 ;
10918 int val2 ;
10919 int ecode2 = 0 ;
10920 PyObject * obj0 = 0 ;
10921 PyObject * obj1 = 0 ;
10922 char * kwnames[] = {
10923 (char *) "self",(char *) "n", NULL
10924 };
10925
10926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10928 if (!SWIG_IsOK(res1)) {
10929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10930 }
10931 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10932 ecode2 = SWIG_AsVal_int(obj1, &val2);
10933 if (!SWIG_IsOK(ecode2)) {
10934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10935 }
10936 arg2 = static_cast< wxPortId >(val2);
10937 {
10938 PyThreadState* __tstate = wxPyBeginAllowThreads();
10939 (arg1)->SetPortId(arg2);
10940 wxPyEndAllowThreads(__tstate);
10941 if (PyErr_Occurred()) SWIG_fail;
10942 }
10943 resultobj = SWIG_Py_Void();
10944 return resultobj;
10945 fail:
10946 return NULL;
10947 }
10948
10949
10950 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10951 PyObject *resultobj = 0;
10952 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10953 wxArchitecture arg2 ;
10954 void *argp1 = 0 ;
10955 int res1 = 0 ;
10956 int val2 ;
10957 int ecode2 = 0 ;
10958 PyObject * obj0 = 0 ;
10959 PyObject * obj1 = 0 ;
10960 char * kwnames[] = {
10961 (char *) "self",(char *) "n", NULL
10962 };
10963
10964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10966 if (!SWIG_IsOK(res1)) {
10967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10968 }
10969 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10970 ecode2 = SWIG_AsVal_int(obj1, &val2);
10971 if (!SWIG_IsOK(ecode2)) {
10972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10973 }
10974 arg2 = static_cast< wxArchitecture >(val2);
10975 {
10976 PyThreadState* __tstate = wxPyBeginAllowThreads();
10977 (arg1)->SetArchitecture(arg2);
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 resultobj = SWIG_Py_Void();
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10989 PyObject *resultobj = 0;
10990 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10991 wxEndianness arg2 ;
10992 void *argp1 = 0 ;
10993 int res1 = 0 ;
10994 int val2 ;
10995 int ecode2 = 0 ;
10996 PyObject * obj0 = 0 ;
10997 PyObject * obj1 = 0 ;
10998 char * kwnames[] = {
10999 (char *) "self",(char *) "n", NULL
11000 };
11001
11002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11004 if (!SWIG_IsOK(res1)) {
11005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11006 }
11007 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11008 ecode2 = SWIG_AsVal_int(obj1, &val2);
11009 if (!SWIG_IsOK(ecode2)) {
11010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11011 }
11012 arg2 = static_cast< wxEndianness >(val2);
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 (arg1)->SetEndianness(arg2);
11016 wxPyEndAllowThreads(__tstate);
11017 if (PyErr_Occurred()) SWIG_fail;
11018 }
11019 resultobj = SWIG_Py_Void();
11020 return resultobj;
11021 fail:
11022 return NULL;
11023 }
11024
11025
11026 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11027 PyObject *resultobj = 0;
11028 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11029 bool result;
11030 void *argp1 = 0 ;
11031 int res1 = 0 ;
11032 PyObject *swig_obj[1] ;
11033
11034 if (!args) SWIG_fail;
11035 swig_obj[0] = args;
11036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11037 if (!SWIG_IsOK(res1)) {
11038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11039 }
11040 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11041 {
11042 PyThreadState* __tstate = wxPyBeginAllowThreads();
11043 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11044 wxPyEndAllowThreads(__tstate);
11045 if (PyErr_Occurred()) SWIG_fail;
11046 }
11047 {
11048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057 PyObject *obj;
11058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11059 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11060 return SWIG_Py_Void();
11061 }
11062
11063 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11064 return SWIG_Python_InitShadowInstance(args);
11065 }
11066
11067 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11068 PyObject *resultobj = 0;
11069 wxWindow *arg1 = (wxWindow *) 0 ;
11070 wxDC *arg2 = 0 ;
11071 bool result;
11072 void *argp1 = 0 ;
11073 int res1 = 0 ;
11074 void *argp2 = 0 ;
11075 int res2 = 0 ;
11076 PyObject * obj0 = 0 ;
11077 PyObject * obj1 = 0 ;
11078 char * kwnames[] = {
11079 (char *) "window",(char *) "dc", NULL
11080 };
11081
11082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11084 if (!SWIG_IsOK(res1)) {
11085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11086 }
11087 arg1 = reinterpret_cast< wxWindow * >(argp1);
11088 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11089 if (!SWIG_IsOK(res2)) {
11090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11091 }
11092 if (!argp2) {
11093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11094 }
11095 arg2 = reinterpret_cast< wxDC * >(argp2);
11096 {
11097 PyThreadState* __tstate = wxPyBeginAllowThreads();
11098 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11099 wxPyEndAllowThreads(__tstate);
11100 if (PyErr_Occurred()) SWIG_fail;
11101 }
11102 {
11103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11104 }
11105 return resultobj;
11106 fail:
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11112 PyObject *resultobj = 0;
11113 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11114 void *argp1 = 0 ;
11115 int res1 = 0 ;
11116 PyObject *swig_obj[1] ;
11117
11118 if (!args) SWIG_fail;
11119 swig_obj[0] = args;
11120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11121 if (!SWIG_IsOK(res1)) {
11122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11123 }
11124 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 delete arg1;
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 resultobj = SWIG_Py_Void();
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11142 wxString result;
11143 void *argp1 = 0 ;
11144 int res1 = 0 ;
11145 PyObject *swig_obj[1] ;
11146
11147 if (!args) SWIG_fail;
11148 swig_obj[0] = args;
11149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11150 if (!SWIG_IsOK(res1)) {
11151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11152 }
11153 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11154 {
11155 PyThreadState* __tstate = wxPyBeginAllowThreads();
11156 result = (arg1)->GetTip();
11157 wxPyEndAllowThreads(__tstate);
11158 if (PyErr_Occurred()) SWIG_fail;
11159 }
11160 {
11161 #if wxUSE_UNICODE
11162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11163 #else
11164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11165 #endif
11166 }
11167 return resultobj;
11168 fail:
11169 return NULL;
11170 }
11171
11172
11173 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11174 PyObject *resultobj = 0;
11175 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11176 size_t result;
11177 void *argp1 = 0 ;
11178 int res1 = 0 ;
11179 PyObject *swig_obj[1] ;
11180
11181 if (!args) SWIG_fail;
11182 swig_obj[0] = args;
11183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11184 if (!SWIG_IsOK(res1)) {
11185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11186 }
11187 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11188 {
11189 PyThreadState* __tstate = wxPyBeginAllowThreads();
11190 result = (size_t)(arg1)->GetCurrentTip();
11191 wxPyEndAllowThreads(__tstate);
11192 if (PyErr_Occurred()) SWIG_fail;
11193 }
11194 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11195 return resultobj;
11196 fail:
11197 return NULL;
11198 }
11199
11200
11201 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11202 PyObject *resultobj = 0;
11203 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11204 wxString *arg2 = 0 ;
11205 wxString result;
11206 void *argp1 = 0 ;
11207 int res1 = 0 ;
11208 bool temp2 = false ;
11209 PyObject * obj0 = 0 ;
11210 PyObject * obj1 = 0 ;
11211 char * kwnames[] = {
11212 (char *) "self",(char *) "tip", NULL
11213 };
11214
11215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11217 if (!SWIG_IsOK(res1)) {
11218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11219 }
11220 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11221 {
11222 arg2 = wxString_in_helper(obj1);
11223 if (arg2 == NULL) SWIG_fail;
11224 temp2 = true;
11225 }
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 {
11233 #if wxUSE_UNICODE
11234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11235 #else
11236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11237 #endif
11238 }
11239 {
11240 if (temp2)
11241 delete arg2;
11242 }
11243 return resultobj;
11244 fail:
11245 {
11246 if (temp2)
11247 delete arg2;
11248 }
11249 return NULL;
11250 }
11251
11252
11253 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11254 PyObject *obj;
11255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11256 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11257 return SWIG_Py_Void();
11258 }
11259
11260 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11261 PyObject *resultobj = 0;
11262 size_t arg1 ;
11263 wxPyTipProvider *result = 0 ;
11264 size_t val1 ;
11265 int ecode1 = 0 ;
11266 PyObject * obj0 = 0 ;
11267 char * kwnames[] = {
11268 (char *) "currentTip", NULL
11269 };
11270
11271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11272 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11273 if (!SWIG_IsOK(ecode1)) {
11274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11275 }
11276 arg1 = static_cast< size_t >(val1);
11277 {
11278 PyThreadState* __tstate = wxPyBeginAllowThreads();
11279 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11280 wxPyEndAllowThreads(__tstate);
11281 if (PyErr_Occurred()) SWIG_fail;
11282 }
11283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11284 return resultobj;
11285 fail:
11286 return NULL;
11287 }
11288
11289
11290 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11291 PyObject *resultobj = 0;
11292 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11293 PyObject *arg2 = (PyObject *) 0 ;
11294 PyObject *arg3 = (PyObject *) 0 ;
11295 void *argp1 = 0 ;
11296 int res1 = 0 ;
11297 PyObject * obj0 = 0 ;
11298 PyObject * obj1 = 0 ;
11299 PyObject * obj2 = 0 ;
11300 char * kwnames[] = {
11301 (char *) "self",(char *) "self",(char *) "_class", NULL
11302 };
11303
11304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11306 if (!SWIG_IsOK(res1)) {
11307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11308 }
11309 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11310 arg2 = obj1;
11311 arg3 = obj2;
11312 {
11313 PyThreadState* __tstate = wxPyBeginAllowThreads();
11314 (arg1)->_setCallbackInfo(arg2,arg3);
11315 wxPyEndAllowThreads(__tstate);
11316 if (PyErr_Occurred()) SWIG_fail;
11317 }
11318 resultobj = SWIG_Py_Void();
11319 return resultobj;
11320 fail:
11321 return NULL;
11322 }
11323
11324
11325 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11326 PyObject *obj;
11327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11328 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11329 return SWIG_Py_Void();
11330 }
11331
11332 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11333 return SWIG_Python_InitShadowInstance(args);
11334 }
11335
11336 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11337 PyObject *resultobj = 0;
11338 wxWindow *arg1 = (wxWindow *) 0 ;
11339 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11340 bool arg3 = (bool) true ;
11341 bool result;
11342 void *argp1 = 0 ;
11343 int res1 = 0 ;
11344 void *argp2 = 0 ;
11345 int res2 = 0 ;
11346 bool val3 ;
11347 int ecode3 = 0 ;
11348 PyObject * obj0 = 0 ;
11349 PyObject * obj1 = 0 ;
11350 PyObject * obj2 = 0 ;
11351 char * kwnames[] = {
11352 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11353 };
11354
11355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11357 if (!SWIG_IsOK(res1)) {
11358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11359 }
11360 arg1 = reinterpret_cast< wxWindow * >(argp1);
11361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11362 if (!SWIG_IsOK(res2)) {
11363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11364 }
11365 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11366 if (obj2) {
11367 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11368 if (!SWIG_IsOK(ecode3)) {
11369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11370 }
11371 arg3 = static_cast< bool >(val3);
11372 }
11373 {
11374 if (!wxPyCheckForApp()) SWIG_fail;
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 result = (bool)wxShowTip(arg1,arg2,arg3);
11377 wxPyEndAllowThreads(__tstate);
11378 if (PyErr_Occurred()) SWIG_fail;
11379 }
11380 {
11381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11382 }
11383 return resultobj;
11384 fail:
11385 return NULL;
11386 }
11387
11388
11389 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11390 PyObject *resultobj = 0;
11391 wxString *arg1 = 0 ;
11392 size_t arg2 ;
11393 wxTipProvider *result = 0 ;
11394 bool temp1 = false ;
11395 size_t val2 ;
11396 int ecode2 = 0 ;
11397 PyObject * obj0 = 0 ;
11398 PyObject * obj1 = 0 ;
11399 char * kwnames[] = {
11400 (char *) "filename",(char *) "currentTip", NULL
11401 };
11402
11403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11404 {
11405 arg1 = wxString_in_helper(obj0);
11406 if (arg1 == NULL) SWIG_fail;
11407 temp1 = true;
11408 }
11409 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11410 if (!SWIG_IsOK(ecode2)) {
11411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11412 }
11413 arg2 = static_cast< size_t >(val2);
11414 {
11415 if (!wxPyCheckForApp()) SWIG_fail;
11416 PyThreadState* __tstate = wxPyBeginAllowThreads();
11417 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11418 wxPyEndAllowThreads(__tstate);
11419 if (PyErr_Occurred()) SWIG_fail;
11420 }
11421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11422 {
11423 if (temp1)
11424 delete arg1;
11425 }
11426 return resultobj;
11427 fail:
11428 {
11429 if (temp1)
11430 delete arg1;
11431 }
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11437 PyObject *resultobj = 0;
11438 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11439 int arg2 = (int) wxID_ANY ;
11440 wxPyTimer *result = 0 ;
11441 void *argp1 = 0 ;
11442 int res1 = 0 ;
11443 int val2 ;
11444 int ecode2 = 0 ;
11445 PyObject * obj0 = 0 ;
11446 PyObject * obj1 = 0 ;
11447 char * kwnames[] = {
11448 (char *) "owner",(char *) "id", NULL
11449 };
11450
11451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11452 if (obj0) {
11453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11454 if (!SWIG_IsOK(res1)) {
11455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11456 }
11457 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11458 }
11459 if (obj1) {
11460 ecode2 = SWIG_AsVal_int(obj1, &val2);
11461 if (!SWIG_IsOK(ecode2)) {
11462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11463 }
11464 arg2 = static_cast< int >(val2);
11465 }
11466 {
11467 if (!wxPyCheckForApp()) SWIG_fail;
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11474 return resultobj;
11475 fail:
11476 return NULL;
11477 }
11478
11479
11480 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11481 PyObject *resultobj = 0;
11482 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11483 void *argp1 = 0 ;
11484 int res1 = 0 ;
11485 PyObject *swig_obj[1] ;
11486
11487 if (!args) SWIG_fail;
11488 swig_obj[0] = args;
11489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11490 if (!SWIG_IsOK(res1)) {
11491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11492 }
11493 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11494 {
11495 PyThreadState* __tstate = wxPyBeginAllowThreads();
11496 delete arg1;
11497
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 resultobj = SWIG_Py_Void();
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11509 PyObject *resultobj = 0;
11510 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11511 PyObject *arg2 = (PyObject *) 0 ;
11512 PyObject *arg3 = (PyObject *) 0 ;
11513 int arg4 = (int) 1 ;
11514 void *argp1 = 0 ;
11515 int res1 = 0 ;
11516 int val4 ;
11517 int ecode4 = 0 ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 PyObject * obj2 = 0 ;
11521 PyObject * obj3 = 0 ;
11522 char * kwnames[] = {
11523 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11524 };
11525
11526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11528 if (!SWIG_IsOK(res1)) {
11529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11530 }
11531 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11532 arg2 = obj1;
11533 arg3 = obj2;
11534 if (obj3) {
11535 ecode4 = SWIG_AsVal_int(obj3, &val4);
11536 if (!SWIG_IsOK(ecode4)) {
11537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11538 }
11539 arg4 = static_cast< int >(val4);
11540 }
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11544 wxPyEndAllowThreads(__tstate);
11545 if (PyErr_Occurred()) SWIG_fail;
11546 }
11547 resultobj = SWIG_Py_Void();
11548 return resultobj;
11549 fail:
11550 return NULL;
11551 }
11552
11553
11554 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11555 PyObject *resultobj = 0;
11556 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11557 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11558 int arg3 = (int) wxID_ANY ;
11559 void *argp1 = 0 ;
11560 int res1 = 0 ;
11561 void *argp2 = 0 ;
11562 int res2 = 0 ;
11563 int val3 ;
11564 int ecode3 = 0 ;
11565 PyObject * obj0 = 0 ;
11566 PyObject * obj1 = 0 ;
11567 PyObject * obj2 = 0 ;
11568 char * kwnames[] = {
11569 (char *) "self",(char *) "owner",(char *) "id", NULL
11570 };
11571
11572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11574 if (!SWIG_IsOK(res1)) {
11575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11576 }
11577 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11579 if (!SWIG_IsOK(res2)) {
11580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11581 }
11582 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11583 if (obj2) {
11584 ecode3 = SWIG_AsVal_int(obj2, &val3);
11585 if (!SWIG_IsOK(ecode3)) {
11586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11587 }
11588 arg3 = static_cast< int >(val3);
11589 }
11590 {
11591 PyThreadState* __tstate = wxPyBeginAllowThreads();
11592 (arg1)->SetOwner(arg2,arg3);
11593 wxPyEndAllowThreads(__tstate);
11594 if (PyErr_Occurred()) SWIG_fail;
11595 }
11596 resultobj = SWIG_Py_Void();
11597 return resultobj;
11598 fail:
11599 return NULL;
11600 }
11601
11602
11603 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11604 PyObject *resultobj = 0;
11605 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11606 wxEvtHandler *result = 0 ;
11607 void *argp1 = 0 ;
11608 int res1 = 0 ;
11609 PyObject *swig_obj[1] ;
11610
11611 if (!args) SWIG_fail;
11612 swig_obj[0] = args;
11613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11614 if (!SWIG_IsOK(res1)) {
11615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11616 }
11617 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11618 {
11619 PyThreadState* __tstate = wxPyBeginAllowThreads();
11620 result = (wxEvtHandler *)(arg1)->GetOwner();
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 {
11625 resultobj = wxPyMake_wxObject(result, 0);
11626 }
11627 return resultobj;
11628 fail:
11629 return NULL;
11630 }
11631
11632
11633 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11634 PyObject *resultobj = 0;
11635 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11636 int arg2 = (int) -1 ;
11637 bool arg3 = (bool) false ;
11638 bool result;
11639 void *argp1 = 0 ;
11640 int res1 = 0 ;
11641 int val2 ;
11642 int ecode2 = 0 ;
11643 bool val3 ;
11644 int ecode3 = 0 ;
11645 PyObject * obj0 = 0 ;
11646 PyObject * obj1 = 0 ;
11647 PyObject * obj2 = 0 ;
11648 char * kwnames[] = {
11649 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11650 };
11651
11652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11656 }
11657 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11658 if (obj1) {
11659 ecode2 = SWIG_AsVal_int(obj1, &val2);
11660 if (!SWIG_IsOK(ecode2)) {
11661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11662 }
11663 arg2 = static_cast< int >(val2);
11664 }
11665 if (obj2) {
11666 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11667 if (!SWIG_IsOK(ecode3)) {
11668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11669 }
11670 arg3 = static_cast< bool >(val3);
11671 }
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (bool)(arg1)->Start(arg2,arg3);
11675 wxPyEndAllowThreads(__tstate);
11676 if (PyErr_Occurred()) SWIG_fail;
11677 }
11678 {
11679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11680 }
11681 return resultobj;
11682 fail:
11683 return NULL;
11684 }
11685
11686
11687 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11688 PyObject *resultobj = 0;
11689 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11690 void *argp1 = 0 ;
11691 int res1 = 0 ;
11692 PyObject *swig_obj[1] ;
11693
11694 if (!args) SWIG_fail;
11695 swig_obj[0] = args;
11696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11697 if (!SWIG_IsOK(res1)) {
11698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11699 }
11700 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 (arg1)->Stop();
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 resultobj = SWIG_Py_Void();
11708 return resultobj;
11709 fail:
11710 return NULL;
11711 }
11712
11713
11714 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11715 PyObject *resultobj = 0;
11716 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11717 void *argp1 = 0 ;
11718 int res1 = 0 ;
11719 PyObject *swig_obj[1] ;
11720
11721 if (!args) SWIG_fail;
11722 swig_obj[0] = args;
11723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11724 if (!SWIG_IsOK(res1)) {
11725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11726 }
11727 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11728 {
11729 PyThreadState* __tstate = wxPyBeginAllowThreads();
11730 (arg1)->Notify();
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 resultobj = SWIG_Py_Void();
11735 return resultobj;
11736 fail:
11737 return NULL;
11738 }
11739
11740
11741 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11742 PyObject *resultobj = 0;
11743 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11744 bool result;
11745 void *argp1 = 0 ;
11746 int res1 = 0 ;
11747 PyObject *swig_obj[1] ;
11748
11749 if (!args) SWIG_fail;
11750 swig_obj[0] = args;
11751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11752 if (!SWIG_IsOK(res1)) {
11753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11754 }
11755 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11759 wxPyEndAllowThreads(__tstate);
11760 if (PyErr_Occurred()) SWIG_fail;
11761 }
11762 {
11763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11764 }
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11772 PyObject *resultobj = 0;
11773 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11774 int result;
11775 void *argp1 = 0 ;
11776 int res1 = 0 ;
11777 PyObject *swig_obj[1] ;
11778
11779 if (!args) SWIG_fail;
11780 swig_obj[0] = args;
11781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11784 }
11785 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 resultobj = SWIG_From_int(static_cast< int >(result));
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11800 PyObject *resultobj = 0;
11801 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11802 int result;
11803 void *argp1 = 0 ;
11804 int res1 = 0 ;
11805 PyObject *swig_obj[1] ;
11806
11807 if (!args) SWIG_fail;
11808 swig_obj[0] = args;
11809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11812 }
11813 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11814 {
11815 PyThreadState* __tstate = wxPyBeginAllowThreads();
11816 result = (int)((wxPyTimer const *)arg1)->GetId();
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 resultobj = SWIG_From_int(static_cast< int >(result));
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11828 PyObject *resultobj = 0;
11829 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11830 bool result;
11831 void *argp1 = 0 ;
11832 int res1 = 0 ;
11833 PyObject *swig_obj[1] ;
11834
11835 if (!args) SWIG_fail;
11836 swig_obj[0] = args;
11837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11838 if (!SWIG_IsOK(res1)) {
11839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11840 }
11841 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11842 {
11843 PyThreadState* __tstate = wxPyBeginAllowThreads();
11844 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11845 wxPyEndAllowThreads(__tstate);
11846 if (PyErr_Occurred()) SWIG_fail;
11847 }
11848 {
11849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11850 }
11851 return resultobj;
11852 fail:
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11858 PyObject *obj;
11859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11860 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11861 return SWIG_Py_Void();
11862 }
11863
11864 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 return SWIG_Python_InitShadowInstance(args);
11866 }
11867
11868 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj = 0;
11870 int arg1 = (int) 0 ;
11871 int arg2 = (int) 0 ;
11872 wxTimerEvent *result = 0 ;
11873 int val1 ;
11874 int ecode1 = 0 ;
11875 int val2 ;
11876 int ecode2 = 0 ;
11877 PyObject * obj0 = 0 ;
11878 PyObject * obj1 = 0 ;
11879 char * kwnames[] = {
11880 (char *) "timerid",(char *) "interval", NULL
11881 };
11882
11883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11884 if (obj0) {
11885 ecode1 = SWIG_AsVal_int(obj0, &val1);
11886 if (!SWIG_IsOK(ecode1)) {
11887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11888 }
11889 arg1 = static_cast< int >(val1);
11890 }
11891 if (obj1) {
11892 ecode2 = SWIG_AsVal_int(obj1, &val2);
11893 if (!SWIG_IsOK(ecode2)) {
11894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11895 }
11896 arg2 = static_cast< int >(val2);
11897 }
11898 {
11899 PyThreadState* __tstate = wxPyBeginAllowThreads();
11900 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11901 wxPyEndAllowThreads(__tstate);
11902 if (PyErr_Occurred()) SWIG_fail;
11903 }
11904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11905 return resultobj;
11906 fail:
11907 return NULL;
11908 }
11909
11910
11911 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11912 PyObject *resultobj = 0;
11913 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11914 int result;
11915 void *argp1 = 0 ;
11916 int res1 = 0 ;
11917 PyObject *swig_obj[1] ;
11918
11919 if (!args) SWIG_fail;
11920 swig_obj[0] = args;
11921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11922 if (!SWIG_IsOK(res1)) {
11923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11924 }
11925 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 resultobj = SWIG_From_int(static_cast< int >(result));
11933 return resultobj;
11934 fail:
11935 return NULL;
11936 }
11937
11938
11939 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11940 PyObject *obj;
11941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11942 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11943 return SWIG_Py_Void();
11944 }
11945
11946 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11947 return SWIG_Python_InitShadowInstance(args);
11948 }
11949
11950 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11951 PyObject *resultobj = 0;
11952 wxTimer *arg1 = 0 ;
11953 wxTimerRunner *result = 0 ;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956
11957 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11959 if (!SWIG_IsOK(res1)) {
11960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11961 }
11962 if (!argp1) {
11963 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11964 }
11965 arg1 = reinterpret_cast< wxTimer * >(argp1);
11966 {
11967 if (!wxPyCheckForApp()) SWIG_fail;
11968 PyThreadState* __tstate = wxPyBeginAllowThreads();
11969 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11981 PyObject *resultobj = 0;
11982 wxTimer *arg1 = 0 ;
11983 int arg2 ;
11984 bool arg3 = (bool) false ;
11985 wxTimerRunner *result = 0 ;
11986 void *argp1 = 0 ;
11987 int res1 = 0 ;
11988 int val2 ;
11989 int ecode2 = 0 ;
11990 bool val3 ;
11991 int ecode3 = 0 ;
11992
11993 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11995 if (!SWIG_IsOK(res1)) {
11996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11997 }
11998 if (!argp1) {
11999 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12000 }
12001 arg1 = reinterpret_cast< wxTimer * >(argp1);
12002 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12003 if (!SWIG_IsOK(ecode2)) {
12004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12005 }
12006 arg2 = static_cast< int >(val2);
12007 if (swig_obj[2]) {
12008 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12009 if (!SWIG_IsOK(ecode3)) {
12010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12011 }
12012 arg3 = static_cast< bool >(val3);
12013 }
12014 {
12015 if (!wxPyCheckForApp()) SWIG_fail;
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12018 wxPyEndAllowThreads(__tstate);
12019 if (PyErr_Occurred()) SWIG_fail;
12020 }
12021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12022 return resultobj;
12023 fail:
12024 return NULL;
12025 }
12026
12027
12028 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12029 int argc;
12030 PyObject *argv[4];
12031
12032 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12033 --argc;
12034 if (argc == 1) {
12035 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12036 }
12037 if ((argc >= 2) && (argc <= 3)) {
12038 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12039 }
12040
12041 fail:
12042 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12043 return NULL;
12044 }
12045
12046
12047 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12048 PyObject *resultobj = 0;
12049 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12050 void *argp1 = 0 ;
12051 int res1 = 0 ;
12052 PyObject *swig_obj[1] ;
12053
12054 if (!args) SWIG_fail;
12055 swig_obj[0] = args;
12056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12057 if (!SWIG_IsOK(res1)) {
12058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12059 }
12060 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 delete arg1;
12064
12065 wxPyEndAllowThreads(__tstate);
12066 if (PyErr_Occurred()) SWIG_fail;
12067 }
12068 resultobj = SWIG_Py_Void();
12069 return resultobj;
12070 fail:
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj = 0;
12077 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12078 int arg2 ;
12079 bool arg3 = (bool) false ;
12080 void *argp1 = 0 ;
12081 int res1 = 0 ;
12082 int val2 ;
12083 int ecode2 = 0 ;
12084 bool val3 ;
12085 int ecode3 = 0 ;
12086 PyObject * obj0 = 0 ;
12087 PyObject * obj1 = 0 ;
12088 PyObject * obj2 = 0 ;
12089 char * kwnames[] = {
12090 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12091 };
12092
12093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12095 if (!SWIG_IsOK(res1)) {
12096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12097 }
12098 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12099 ecode2 = SWIG_AsVal_int(obj1, &val2);
12100 if (!SWIG_IsOK(ecode2)) {
12101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12102 }
12103 arg2 = static_cast< int >(val2);
12104 if (obj2) {
12105 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12106 if (!SWIG_IsOK(ecode3)) {
12107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12108 }
12109 arg3 = static_cast< bool >(val3);
12110 }
12111 {
12112 PyThreadState* __tstate = wxPyBeginAllowThreads();
12113 (arg1)->Start(arg2,arg3);
12114 wxPyEndAllowThreads(__tstate);
12115 if (PyErr_Occurred()) SWIG_fail;
12116 }
12117 resultobj = SWIG_Py_Void();
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12125 PyObject *obj;
12126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12127 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12128 return SWIG_Py_Void();
12129 }
12130
12131 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12132 return SWIG_Python_InitShadowInstance(args);
12133 }
12134
12135 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12136 PyObject *resultobj = 0;
12137 wxLog *result = 0 ;
12138
12139 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12140 {
12141 PyThreadState* __tstate = wxPyBeginAllowThreads();
12142 result = (wxLog *)new wxLog();
12143 wxPyEndAllowThreads(__tstate);
12144 if (PyErr_Occurred()) SWIG_fail;
12145 }
12146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12147 return resultobj;
12148 fail:
12149 return NULL;
12150 }
12151
12152
12153 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154 PyObject *resultobj = 0;
12155 wxLog *arg1 = (wxLog *) 0 ;
12156 void *argp1 = 0 ;
12157 int res1 = 0 ;
12158 PyObject *swig_obj[1] ;
12159
12160 if (!args) SWIG_fail;
12161 swig_obj[0] = args;
12162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12163 if (!SWIG_IsOK(res1)) {
12164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12165 }
12166 arg1 = reinterpret_cast< wxLog * >(argp1);
12167 {
12168 PyThreadState* __tstate = wxPyBeginAllowThreads();
12169 delete arg1;
12170
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 resultobj = SWIG_Py_Void();
12175 return resultobj;
12176 fail:
12177 return NULL;
12178 }
12179
12180
12181 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12182 PyObject *resultobj = 0;
12183 bool result;
12184
12185 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 result = (bool)wxLog::IsEnabled();
12189 wxPyEndAllowThreads(__tstate);
12190 if (PyErr_Occurred()) SWIG_fail;
12191 }
12192 {
12193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12194 }
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12202 PyObject *resultobj = 0;
12203 bool arg1 = (bool) true ;
12204 bool result;
12205 bool val1 ;
12206 int ecode1 = 0 ;
12207 PyObject * obj0 = 0 ;
12208 char * kwnames[] = {
12209 (char *) "doIt", NULL
12210 };
12211
12212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12213 if (obj0) {
12214 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12215 if (!SWIG_IsOK(ecode1)) {
12216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12217 }
12218 arg1 = static_cast< bool >(val1);
12219 }
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = (bool)wxLog::EnableLogging(arg1);
12223 wxPyEndAllowThreads(__tstate);
12224 if (PyErr_Occurred()) SWIG_fail;
12225 }
12226 {
12227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12228 }
12229 return resultobj;
12230 fail:
12231 return NULL;
12232 }
12233
12234
12235 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12236 PyObject *resultobj = 0;
12237 wxLogLevel arg1 ;
12238 wxChar *arg2 = (wxChar *) 0 ;
12239 time_t arg3 ;
12240 unsigned long val1 ;
12241 int ecode1 = 0 ;
12242 void *argp2 = 0 ;
12243 int res2 = 0 ;
12244 unsigned int val3 ;
12245 int ecode3 = 0 ;
12246 PyObject * obj0 = 0 ;
12247 PyObject * obj1 = 0 ;
12248 PyObject * obj2 = 0 ;
12249 char * kwnames[] = {
12250 (char *) "level",(char *) "szString",(char *) "t", NULL
12251 };
12252
12253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12254 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12255 if (!SWIG_IsOK(ecode1)) {
12256 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12257 }
12258 arg1 = static_cast< wxLogLevel >(val1);
12259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12260 if (!SWIG_IsOK(res2)) {
12261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12262 }
12263 arg2 = reinterpret_cast< wxChar * >(argp2);
12264 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12265 if (!SWIG_IsOK(ecode3)) {
12266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12267 }
12268 arg3 = static_cast< time_t >(val3);
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 resultobj = SWIG_Py_Void();
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12283 PyObject *resultobj = 0;
12284 wxLog *arg1 = (wxLog *) 0 ;
12285 void *argp1 = 0 ;
12286 int res1 = 0 ;
12287 PyObject *swig_obj[1] ;
12288
12289 if (!args) SWIG_fail;
12290 swig_obj[0] = args;
12291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12292 if (!SWIG_IsOK(res1)) {
12293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12294 }
12295 arg1 = reinterpret_cast< wxLog * >(argp1);
12296 {
12297 PyThreadState* __tstate = wxPyBeginAllowThreads();
12298 (arg1)->Flush();
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 resultobj = SWIG_Py_Void();
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12310 PyObject *resultobj = 0;
12311
12312 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 wxLog::FlushActive();
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 resultobj = SWIG_Py_Void();
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12327 PyObject *resultobj = 0;
12328 wxLog *result = 0 ;
12329
12330 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12331 {
12332 PyThreadState* __tstate = wxPyBeginAllowThreads();
12333 result = (wxLog *)wxLog::GetActiveTarget();
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12338 return resultobj;
12339 fail:
12340 return NULL;
12341 }
12342
12343
12344 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12345 PyObject *resultobj = 0;
12346 wxLog *arg1 = (wxLog *) 0 ;
12347 wxLog *result = 0 ;
12348 int res1 = 0 ;
12349 PyObject * obj0 = 0 ;
12350 char * kwnames[] = {
12351 (char *) "pLogger", NULL
12352 };
12353
12354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12355 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12356 if (!SWIG_IsOK(res1)) {
12357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12358 }
12359 {
12360 PyThreadState* __tstate = wxPyBeginAllowThreads();
12361 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12362 wxPyEndAllowThreads(__tstate);
12363 if (PyErr_Occurred()) SWIG_fail;
12364 }
12365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12366 return resultobj;
12367 fail:
12368 return NULL;
12369 }
12370
12371
12372 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12373 PyObject *resultobj = 0;
12374
12375 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12376 {
12377 PyThreadState* __tstate = wxPyBeginAllowThreads();
12378 wxLog::Suspend();
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 resultobj = SWIG_Py_Void();
12383 return resultobj;
12384 fail:
12385 return NULL;
12386 }
12387
12388
12389 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12390 PyObject *resultobj = 0;
12391
12392 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12393 {
12394 PyThreadState* __tstate = wxPyBeginAllowThreads();
12395 wxLog::Resume();
12396 wxPyEndAllowThreads(__tstate);
12397 if (PyErr_Occurred()) SWIG_fail;
12398 }
12399 resultobj = SWIG_Py_Void();
12400 return resultobj;
12401 fail:
12402 return NULL;
12403 }
12404
12405
12406 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12407 PyObject *resultobj = 0;
12408 bool arg1 = (bool) true ;
12409 bool val1 ;
12410 int ecode1 = 0 ;
12411 PyObject * obj0 = 0 ;
12412 char * kwnames[] = {
12413 (char *) "bVerbose", NULL
12414 };
12415
12416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12417 if (obj0) {
12418 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12419 if (!SWIG_IsOK(ecode1)) {
12420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12421 }
12422 arg1 = static_cast< bool >(val1);
12423 }
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 wxLog::SetVerbose(arg1);
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_Py_Void();
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12438 PyObject *resultobj = 0;
12439 wxLogLevel arg1 ;
12440 unsigned long val1 ;
12441 int ecode1 = 0 ;
12442 PyObject * obj0 = 0 ;
12443 char * kwnames[] = {
12444 (char *) "logLevel", NULL
12445 };
12446
12447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12448 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12449 if (!SWIG_IsOK(ecode1)) {
12450 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12451 }
12452 arg1 = static_cast< wxLogLevel >(val1);
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 wxLog::SetLogLevel(arg1);
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 resultobj = SWIG_Py_Void();
12460 return resultobj;
12461 fail:
12462 return NULL;
12463 }
12464
12465
12466 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12467 PyObject *resultobj = 0;
12468
12469 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12470 {
12471 PyThreadState* __tstate = wxPyBeginAllowThreads();
12472 wxLog::DontCreateOnDemand();
12473 wxPyEndAllowThreads(__tstate);
12474 if (PyErr_Occurred()) SWIG_fail;
12475 }
12476 resultobj = SWIG_Py_Void();
12477 return resultobj;
12478 fail:
12479 return NULL;
12480 }
12481
12482
12483 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12484 PyObject *resultobj = 0;
12485 bool arg1 = (bool) true ;
12486 bool val1 ;
12487 int ecode1 = 0 ;
12488 PyObject * obj0 = 0 ;
12489 char * kwnames[] = {
12490 (char *) "bRepetCounting", NULL
12491 };
12492
12493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12494 if (obj0) {
12495 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12496 if (!SWIG_IsOK(ecode1)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12498 }
12499 arg1 = static_cast< bool >(val1);
12500 }
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 wxLog::SetRepetitionCounting(arg1);
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 resultobj = SWIG_Py_Void();
12508 return resultobj;
12509 fail:
12510 return NULL;
12511 }
12512
12513
12514 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 PyObject *resultobj = 0;
12516 bool result;
12517
12518 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 result = (bool)wxLog::GetRepetitionCounting();
12522 wxPyEndAllowThreads(__tstate);
12523 if (PyErr_Occurred()) SWIG_fail;
12524 }
12525 {
12526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12527 }
12528 return resultobj;
12529 fail:
12530 return NULL;
12531 }
12532
12533
12534 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12535 PyObject *resultobj = 0;
12536 wxTraceMask arg1 ;
12537 unsigned long val1 ;
12538 int ecode1 = 0 ;
12539 PyObject * obj0 = 0 ;
12540 char * kwnames[] = {
12541 (char *) "ulMask", NULL
12542 };
12543
12544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12545 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12546 if (!SWIG_IsOK(ecode1)) {
12547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12548 }
12549 arg1 = static_cast< wxTraceMask >(val1);
12550 {
12551 PyThreadState* __tstate = wxPyBeginAllowThreads();
12552 wxLog::SetTraceMask(arg1);
12553 wxPyEndAllowThreads(__tstate);
12554 if (PyErr_Occurred()) SWIG_fail;
12555 }
12556 resultobj = SWIG_Py_Void();
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj = 0;
12565 wxString *arg1 = 0 ;
12566 bool temp1 = false ;
12567 PyObject * obj0 = 0 ;
12568 char * kwnames[] = {
12569 (char *) "str", NULL
12570 };
12571
12572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12573 {
12574 arg1 = wxString_in_helper(obj0);
12575 if (arg1 == NULL) SWIG_fail;
12576 temp1 = true;
12577 }
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 wxLog::AddTraceMask((wxString const &)*arg1);
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 resultobj = SWIG_Py_Void();
12585 {
12586 if (temp1)
12587 delete arg1;
12588 }
12589 return resultobj;
12590 fail:
12591 {
12592 if (temp1)
12593 delete arg1;
12594 }
12595 return NULL;
12596 }
12597
12598
12599 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12600 PyObject *resultobj = 0;
12601 wxString *arg1 = 0 ;
12602 bool temp1 = false ;
12603 PyObject * obj0 = 0 ;
12604 char * kwnames[] = {
12605 (char *) "str", NULL
12606 };
12607
12608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12609 {
12610 arg1 = wxString_in_helper(obj0);
12611 if (arg1 == NULL) SWIG_fail;
12612 temp1 = true;
12613 }
12614 {
12615 PyThreadState* __tstate = wxPyBeginAllowThreads();
12616 wxLog::RemoveTraceMask((wxString const &)*arg1);
12617 wxPyEndAllowThreads(__tstate);
12618 if (PyErr_Occurred()) SWIG_fail;
12619 }
12620 resultobj = SWIG_Py_Void();
12621 {
12622 if (temp1)
12623 delete arg1;
12624 }
12625 return resultobj;
12626 fail:
12627 {
12628 if (temp1)
12629 delete arg1;
12630 }
12631 return NULL;
12632 }
12633
12634
12635 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12636 PyObject *resultobj = 0;
12637
12638 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12639 {
12640 PyThreadState* __tstate = wxPyBeginAllowThreads();
12641 wxLog::ClearTraceMasks();
12642 wxPyEndAllowThreads(__tstate);
12643 if (PyErr_Occurred()) SWIG_fail;
12644 }
12645 resultobj = SWIG_Py_Void();
12646 return resultobj;
12647 fail:
12648 return NULL;
12649 }
12650
12651
12652 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12653 PyObject *resultobj = 0;
12654 wxArrayString *result = 0 ;
12655
12656 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12657 {
12658 PyThreadState* __tstate = wxPyBeginAllowThreads();
12659 {
12660 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12661 result = (wxArrayString *) &_result_ref;
12662 }
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 {
12667 resultobj = wxArrayString2PyList_helper(*result);
12668 }
12669 return resultobj;
12670 fail:
12671 return NULL;
12672 }
12673
12674
12675 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj = 0;
12677 wxChar *arg1 = (wxChar *) 0 ;
12678 void *argp1 = 0 ;
12679 int res1 = 0 ;
12680 PyObject * obj0 = 0 ;
12681 char * kwnames[] = {
12682 (char *) "ts", NULL
12683 };
12684
12685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12687 if (!SWIG_IsOK(res1)) {
12688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12689 }
12690 arg1 = reinterpret_cast< wxChar * >(argp1);
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 wxLog::SetTimestamp((wxChar const *)arg1);
12694 wxPyEndAllowThreads(__tstate);
12695 if (PyErr_Occurred()) SWIG_fail;
12696 }
12697 resultobj = SWIG_Py_Void();
12698 return resultobj;
12699 fail:
12700 return NULL;
12701 }
12702
12703
12704 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12705 PyObject *resultobj = 0;
12706 bool result;
12707
12708 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12709 {
12710 PyThreadState* __tstate = wxPyBeginAllowThreads();
12711 result = (bool)wxLog::GetVerbose();
12712 wxPyEndAllowThreads(__tstate);
12713 if (PyErr_Occurred()) SWIG_fail;
12714 }
12715 {
12716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12717 }
12718 return resultobj;
12719 fail:
12720 return NULL;
12721 }
12722
12723
12724 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12725 PyObject *resultobj = 0;
12726 wxTraceMask result;
12727
12728 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12729 {
12730 PyThreadState* __tstate = wxPyBeginAllowThreads();
12731 result = (wxTraceMask)wxLog::GetTraceMask();
12732 wxPyEndAllowThreads(__tstate);
12733 if (PyErr_Occurred()) SWIG_fail;
12734 }
12735 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12736 return resultobj;
12737 fail:
12738 return NULL;
12739 }
12740
12741
12742 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12743 PyObject *resultobj = 0;
12744 wxChar *arg1 = (wxChar *) 0 ;
12745 bool result;
12746 void *argp1 = 0 ;
12747 int res1 = 0 ;
12748 PyObject * obj0 = 0 ;
12749 char * kwnames[] = {
12750 (char *) "mask", NULL
12751 };
12752
12753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12755 if (!SWIG_IsOK(res1)) {
12756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12757 }
12758 arg1 = reinterpret_cast< wxChar * >(argp1);
12759 {
12760 PyThreadState* __tstate = wxPyBeginAllowThreads();
12761 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12762 wxPyEndAllowThreads(__tstate);
12763 if (PyErr_Occurred()) SWIG_fail;
12764 }
12765 {
12766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12767 }
12768 return resultobj;
12769 fail:
12770 return NULL;
12771 }
12772
12773
12774 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12775 PyObject *resultobj = 0;
12776 wxLogLevel result;
12777
12778 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12779 {
12780 PyThreadState* __tstate = wxPyBeginAllowThreads();
12781 result = (wxLogLevel)wxLog::GetLogLevel();
12782 wxPyEndAllowThreads(__tstate);
12783 if (PyErr_Occurred()) SWIG_fail;
12784 }
12785 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12786 return resultobj;
12787 fail:
12788 return NULL;
12789 }
12790
12791
12792 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12793 PyObject *resultobj = 0;
12794 wxChar *result = 0 ;
12795
12796 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12797 {
12798 PyThreadState* __tstate = wxPyBeginAllowThreads();
12799 result = (wxChar *)wxLog::GetTimestamp();
12800 wxPyEndAllowThreads(__tstate);
12801 if (PyErr_Occurred()) SWIG_fail;
12802 }
12803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12804 return resultobj;
12805 fail:
12806 return NULL;
12807 }
12808
12809
12810 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12811 PyObject *resultobj = 0;
12812 wxString result;
12813
12814 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 result = wxLog_TimeStamp();
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 {
12822 #if wxUSE_UNICODE
12823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12824 #else
12825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12826 #endif
12827 }
12828 return resultobj;
12829 fail:
12830 return NULL;
12831 }
12832
12833
12834 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12835 PyObject *resultobj = 0;
12836 wxLog *arg1 = (wxLog *) 0 ;
12837 void *argp1 = 0 ;
12838 int res1 = 0 ;
12839 PyObject *swig_obj[1] ;
12840
12841 if (!args) SWIG_fail;
12842 swig_obj[0] = args;
12843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12844 if (!SWIG_IsOK(res1)) {
12845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12846 }
12847 arg1 = reinterpret_cast< wxLog * >(argp1);
12848 {
12849 PyThreadState* __tstate = wxPyBeginAllowThreads();
12850 wxLog_Destroy(arg1);
12851 wxPyEndAllowThreads(__tstate);
12852 if (PyErr_Occurred()) SWIG_fail;
12853 }
12854 resultobj = SWIG_Py_Void();
12855 return resultobj;
12856 fail:
12857 return NULL;
12858 }
12859
12860
12861 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12862 PyObject *obj;
12863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12864 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12865 return SWIG_Py_Void();
12866 }
12867
12868 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12869 return SWIG_Python_InitShadowInstance(args);
12870 }
12871
12872 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12873 PyObject *resultobj = 0;
12874 wxLogStderr *result = 0 ;
12875
12876 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 result = (wxLogStderr *)new wxLogStderr();
12880 wxPyEndAllowThreads(__tstate);
12881 if (PyErr_Occurred()) SWIG_fail;
12882 }
12883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12884 return resultobj;
12885 fail:
12886 return NULL;
12887 }
12888
12889
12890 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12891 PyObject *obj;
12892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12893 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12894 return SWIG_Py_Void();
12895 }
12896
12897 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12898 return SWIG_Python_InitShadowInstance(args);
12899 }
12900
12901 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12902 PyObject *resultobj = 0;
12903 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12904 wxLogTextCtrl *result = 0 ;
12905 void *argp1 = 0 ;
12906 int res1 = 0 ;
12907 PyObject * obj0 = 0 ;
12908 char * kwnames[] = {
12909 (char *) "pTextCtrl", NULL
12910 };
12911
12912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12914 if (!SWIG_IsOK(res1)) {
12915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12916 }
12917 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12918 {
12919 PyThreadState* __tstate = wxPyBeginAllowThreads();
12920 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12921 wxPyEndAllowThreads(__tstate);
12922 if (PyErr_Occurred()) SWIG_fail;
12923 }
12924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12925 return resultobj;
12926 fail:
12927 return NULL;
12928 }
12929
12930
12931 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12932 PyObject *obj;
12933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12934 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12935 return SWIG_Py_Void();
12936 }
12937
12938 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 return SWIG_Python_InitShadowInstance(args);
12940 }
12941
12942 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12943 PyObject *resultobj = 0;
12944 wxLogGui *result = 0 ;
12945
12946 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12947 {
12948 PyThreadState* __tstate = wxPyBeginAllowThreads();
12949 result = (wxLogGui *)new wxLogGui();
12950 wxPyEndAllowThreads(__tstate);
12951 if (PyErr_Occurred()) SWIG_fail;
12952 }
12953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 PyObject *obj;
12962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12963 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12964 return SWIG_Py_Void();
12965 }
12966
12967 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 return SWIG_Python_InitShadowInstance(args);
12969 }
12970
12971 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12972 PyObject *resultobj = 0;
12973 wxFrame *arg1 = (wxFrame *) 0 ;
12974 wxString *arg2 = 0 ;
12975 bool arg3 = (bool) true ;
12976 bool arg4 = (bool) true ;
12977 wxLogWindow *result = 0 ;
12978 void *argp1 = 0 ;
12979 int res1 = 0 ;
12980 bool temp2 = false ;
12981 bool val3 ;
12982 int ecode3 = 0 ;
12983 bool val4 ;
12984 int ecode4 = 0 ;
12985 PyObject * obj0 = 0 ;
12986 PyObject * obj1 = 0 ;
12987 PyObject * obj2 = 0 ;
12988 PyObject * obj3 = 0 ;
12989 char * kwnames[] = {
12990 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12991 };
12992
12993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12995 if (!SWIG_IsOK(res1)) {
12996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12997 }
12998 arg1 = reinterpret_cast< wxFrame * >(argp1);
12999 {
13000 arg2 = wxString_in_helper(obj1);
13001 if (arg2 == NULL) SWIG_fail;
13002 temp2 = true;
13003 }
13004 if (obj2) {
13005 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13006 if (!SWIG_IsOK(ecode3)) {
13007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13008 }
13009 arg3 = static_cast< bool >(val3);
13010 }
13011 if (obj3) {
13012 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13013 if (!SWIG_IsOK(ecode4)) {
13014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13015 }
13016 arg4 = static_cast< bool >(val4);
13017 }
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13025 {
13026 if (temp2)
13027 delete arg2;
13028 }
13029 return resultobj;
13030 fail:
13031 {
13032 if (temp2)
13033 delete arg2;
13034 }
13035 return NULL;
13036 }
13037
13038
13039 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13040 PyObject *resultobj = 0;
13041 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13042 bool arg2 = (bool) true ;
13043 void *argp1 = 0 ;
13044 int res1 = 0 ;
13045 bool val2 ;
13046 int ecode2 = 0 ;
13047 PyObject * obj0 = 0 ;
13048 PyObject * obj1 = 0 ;
13049 char * kwnames[] = {
13050 (char *) "self",(char *) "bShow", NULL
13051 };
13052
13053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13055 if (!SWIG_IsOK(res1)) {
13056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13057 }
13058 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13059 if (obj1) {
13060 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13061 if (!SWIG_IsOK(ecode2)) {
13062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13063 }
13064 arg2 = static_cast< bool >(val2);
13065 }
13066 {
13067 PyThreadState* __tstate = wxPyBeginAllowThreads();
13068 (arg1)->Show(arg2);
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 resultobj = SWIG_Py_Void();
13073 return resultobj;
13074 fail:
13075 return NULL;
13076 }
13077
13078
13079 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13080 PyObject *resultobj = 0;
13081 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13082 wxFrame *result = 0 ;
13083 void *argp1 = 0 ;
13084 int res1 = 0 ;
13085 PyObject *swig_obj[1] ;
13086
13087 if (!args) SWIG_fail;
13088 swig_obj[0] = args;
13089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13090 if (!SWIG_IsOK(res1)) {
13091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13092 }
13093 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13094 {
13095 PyThreadState* __tstate = wxPyBeginAllowThreads();
13096 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 {
13101 resultobj = wxPyMake_wxObject(result, (bool)0);
13102 }
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13110 PyObject *resultobj = 0;
13111 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13112 wxLog *result = 0 ;
13113 void *argp1 = 0 ;
13114 int res1 = 0 ;
13115 PyObject *swig_obj[1] ;
13116
13117 if (!args) SWIG_fail;
13118 swig_obj[0] = args;
13119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13120 if (!SWIG_IsOK(res1)) {
13121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13122 }
13123 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13124 {
13125 PyThreadState* __tstate = wxPyBeginAllowThreads();
13126 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13138 PyObject *resultobj = 0;
13139 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13140 bool result;
13141 void *argp1 = 0 ;
13142 int res1 = 0 ;
13143 PyObject *swig_obj[1] ;
13144
13145 if (!args) SWIG_fail;
13146 swig_obj[0] = args;
13147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13148 if (!SWIG_IsOK(res1)) {
13149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13150 }
13151 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13152 {
13153 PyThreadState* __tstate = wxPyBeginAllowThreads();
13154 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 {
13159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj = 0;
13169 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13170 bool arg2 ;
13171 void *argp1 = 0 ;
13172 int res1 = 0 ;
13173 bool val2 ;
13174 int ecode2 = 0 ;
13175 PyObject * obj0 = 0 ;
13176 PyObject * obj1 = 0 ;
13177 char * kwnames[] = {
13178 (char *) "self",(char *) "bDoPass", NULL
13179 };
13180
13181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13183 if (!SWIG_IsOK(res1)) {
13184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13185 }
13186 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13187 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13188 if (!SWIG_IsOK(ecode2)) {
13189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13190 }
13191 arg2 = static_cast< bool >(val2);
13192 {
13193 PyThreadState* __tstate = wxPyBeginAllowThreads();
13194 (arg1)->PassMessages(arg2);
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 *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13206 PyObject *obj;
13207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13208 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13209 return SWIG_Py_Void();
13210 }
13211
13212 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13213 return SWIG_Python_InitShadowInstance(args);
13214 }
13215
13216 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13217 PyObject *resultobj = 0;
13218 wxLog *arg1 = (wxLog *) 0 ;
13219 wxLogChain *result = 0 ;
13220 void *argp1 = 0 ;
13221 int res1 = 0 ;
13222 PyObject * obj0 = 0 ;
13223 char * kwnames[] = {
13224 (char *) "logger", NULL
13225 };
13226
13227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13229 if (!SWIG_IsOK(res1)) {
13230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13231 }
13232 arg1 = reinterpret_cast< wxLog * >(argp1);
13233 {
13234 PyThreadState* __tstate = wxPyBeginAllowThreads();
13235 result = (wxLogChain *)new wxLogChain(arg1);
13236 wxPyEndAllowThreads(__tstate);
13237 if (PyErr_Occurred()) SWIG_fail;
13238 }
13239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13240 return resultobj;
13241 fail:
13242 return NULL;
13243 }
13244
13245
13246 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13247 PyObject *resultobj = 0;
13248 wxLogChain *arg1 = (wxLogChain *) 0 ;
13249 wxLog *arg2 = (wxLog *) 0 ;
13250 void *argp1 = 0 ;
13251 int res1 = 0 ;
13252 void *argp2 = 0 ;
13253 int res2 = 0 ;
13254 PyObject * obj0 = 0 ;
13255 PyObject * obj1 = 0 ;
13256 char * kwnames[] = {
13257 (char *) "self",(char *) "logger", NULL
13258 };
13259
13260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13262 if (!SWIG_IsOK(res1)) {
13263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13264 }
13265 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13267 if (!SWIG_IsOK(res2)) {
13268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13269 }
13270 arg2 = reinterpret_cast< wxLog * >(argp2);
13271 {
13272 PyThreadState* __tstate = wxPyBeginAllowThreads();
13273 (arg1)->SetLog(arg2);
13274 wxPyEndAllowThreads(__tstate);
13275 if (PyErr_Occurred()) SWIG_fail;
13276 }
13277 resultobj = SWIG_Py_Void();
13278 return resultobj;
13279 fail:
13280 return NULL;
13281 }
13282
13283
13284 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13285 PyObject *resultobj = 0;
13286 wxLogChain *arg1 = (wxLogChain *) 0 ;
13287 bool arg2 ;
13288 void *argp1 = 0 ;
13289 int res1 = 0 ;
13290 bool val2 ;
13291 int ecode2 = 0 ;
13292 PyObject * obj0 = 0 ;
13293 PyObject * obj1 = 0 ;
13294 char * kwnames[] = {
13295 (char *) "self",(char *) "bDoPass", NULL
13296 };
13297
13298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13300 if (!SWIG_IsOK(res1)) {
13301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13302 }
13303 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13304 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13305 if (!SWIG_IsOK(ecode2)) {
13306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13307 }
13308 arg2 = static_cast< bool >(val2);
13309 {
13310 PyThreadState* __tstate = wxPyBeginAllowThreads();
13311 (arg1)->PassMessages(arg2);
13312 wxPyEndAllowThreads(__tstate);
13313 if (PyErr_Occurred()) SWIG_fail;
13314 }
13315 resultobj = SWIG_Py_Void();
13316 return resultobj;
13317 fail:
13318 return NULL;
13319 }
13320
13321
13322 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13323 PyObject *resultobj = 0;
13324 wxLogChain *arg1 = (wxLogChain *) 0 ;
13325 bool result;
13326 void *argp1 = 0 ;
13327 int res1 = 0 ;
13328 PyObject *swig_obj[1] ;
13329
13330 if (!args) SWIG_fail;
13331 swig_obj[0] = args;
13332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13333 if (!SWIG_IsOK(res1)) {
13334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13335 }
13336 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13337 {
13338 PyThreadState* __tstate = wxPyBeginAllowThreads();
13339 result = (bool)(arg1)->IsPassingMessages();
13340 wxPyEndAllowThreads(__tstate);
13341 if (PyErr_Occurred()) SWIG_fail;
13342 }
13343 {
13344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13345 }
13346 return resultobj;
13347 fail:
13348 return NULL;
13349 }
13350
13351
13352 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13353 PyObject *resultobj = 0;
13354 wxLogChain *arg1 = (wxLogChain *) 0 ;
13355 wxLog *result = 0 ;
13356 void *argp1 = 0 ;
13357 int res1 = 0 ;
13358 PyObject *swig_obj[1] ;
13359
13360 if (!args) SWIG_fail;
13361 swig_obj[0] = args;
13362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13363 if (!SWIG_IsOK(res1)) {
13364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13365 }
13366 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 result = (wxLog *)(arg1)->GetOldLog();
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13374 return resultobj;
13375 fail:
13376 return NULL;
13377 }
13378
13379
13380 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13381 PyObject *obj;
13382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13383 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13384 return SWIG_Py_Void();
13385 }
13386
13387 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13388 return SWIG_Python_InitShadowInstance(args);
13389 }
13390
13391 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392 PyObject *resultobj = 0;
13393 wxLogBuffer *result = 0 ;
13394
13395 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13396 {
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 result = (wxLogBuffer *)new wxLogBuffer();
13399 wxPyEndAllowThreads(__tstate);
13400 if (PyErr_Occurred()) SWIG_fail;
13401 }
13402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13410 PyObject *resultobj = 0;
13411 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13412 wxString *result = 0 ;
13413 void *argp1 = 0 ;
13414 int res1 = 0 ;
13415 PyObject *swig_obj[1] ;
13416
13417 if (!args) SWIG_fail;
13418 swig_obj[0] = args;
13419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13420 if (!SWIG_IsOK(res1)) {
13421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13422 }
13423 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 {
13427 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13428 result = (wxString *) &_result_ref;
13429 }
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 {
13434 #if wxUSE_UNICODE
13435 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13436 #else
13437 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13438 #endif
13439 }
13440 return resultobj;
13441 fail:
13442 return NULL;
13443 }
13444
13445
13446 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13447 PyObject *obj;
13448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13449 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13450 return SWIG_Py_Void();
13451 }
13452
13453 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13454 return SWIG_Python_InitShadowInstance(args);
13455 }
13456
13457 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13458 PyObject *resultobj = 0;
13459 unsigned long result;
13460
13461 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13462 {
13463 PyThreadState* __tstate = wxPyBeginAllowThreads();
13464 result = (unsigned long)wxSysErrorCode();
13465 wxPyEndAllowThreads(__tstate);
13466 if (PyErr_Occurred()) SWIG_fail;
13467 }
13468 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13469 return resultobj;
13470 fail:
13471 return NULL;
13472 }
13473
13474
13475 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13476 PyObject *resultobj = 0;
13477 unsigned long arg1 = (unsigned long) 0 ;
13478 wxString result;
13479 unsigned long val1 ;
13480 int ecode1 = 0 ;
13481 PyObject * obj0 = 0 ;
13482 char * kwnames[] = {
13483 (char *) "nErrCode", NULL
13484 };
13485
13486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13487 if (obj0) {
13488 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13489 if (!SWIG_IsOK(ecode1)) {
13490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13491 }
13492 arg1 = static_cast< unsigned long >(val1);
13493 }
13494 {
13495 PyThreadState* __tstate = wxPyBeginAllowThreads();
13496 result = wxSysErrorMsg(arg1);
13497 wxPyEndAllowThreads(__tstate);
13498 if (PyErr_Occurred()) SWIG_fail;
13499 }
13500 {
13501 #if wxUSE_UNICODE
13502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13503 #else
13504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13505 #endif
13506 }
13507 return resultobj;
13508 fail:
13509 return NULL;
13510 }
13511
13512
13513 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13514 PyObject *resultobj = 0;
13515 wxString *arg1 = 0 ;
13516 bool temp1 = false ;
13517 PyObject * obj0 = 0 ;
13518 char * kwnames[] = {
13519 (char *) "msg", NULL
13520 };
13521
13522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13523 {
13524 arg1 = wxString_in_helper(obj0);
13525 if (arg1 == NULL) SWIG_fail;
13526 temp1 = true;
13527 }
13528 {
13529 PyThreadState* __tstate = wxPyBeginAllowThreads();
13530 wxPyLogFatalError((wxString const &)*arg1);
13531 wxPyEndAllowThreads(__tstate);
13532 if (PyErr_Occurred()) SWIG_fail;
13533 }
13534 resultobj = SWIG_Py_Void();
13535 {
13536 if (temp1)
13537 delete arg1;
13538 }
13539 return resultobj;
13540 fail:
13541 {
13542 if (temp1)
13543 delete arg1;
13544 }
13545 return NULL;
13546 }
13547
13548
13549 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13550 PyObject *resultobj = 0;
13551 wxString *arg1 = 0 ;
13552 bool temp1 = false ;
13553 PyObject * obj0 = 0 ;
13554 char * kwnames[] = {
13555 (char *) "msg", NULL
13556 };
13557
13558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13559 {
13560 arg1 = wxString_in_helper(obj0);
13561 if (arg1 == NULL) SWIG_fail;
13562 temp1 = true;
13563 }
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 wxPyLogError((wxString const &)*arg1);
13567 wxPyEndAllowThreads(__tstate);
13568 if (PyErr_Occurred()) SWIG_fail;
13569 }
13570 resultobj = SWIG_Py_Void();
13571 {
13572 if (temp1)
13573 delete arg1;
13574 }
13575 return resultobj;
13576 fail:
13577 {
13578 if (temp1)
13579 delete arg1;
13580 }
13581 return NULL;
13582 }
13583
13584
13585 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj = 0;
13587 wxString *arg1 = 0 ;
13588 bool temp1 = false ;
13589 PyObject * obj0 = 0 ;
13590 char * kwnames[] = {
13591 (char *) "msg", NULL
13592 };
13593
13594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13595 {
13596 arg1 = wxString_in_helper(obj0);
13597 if (arg1 == NULL) SWIG_fail;
13598 temp1 = true;
13599 }
13600 {
13601 PyThreadState* __tstate = wxPyBeginAllowThreads();
13602 wxPyLogWarning((wxString const &)*arg1);
13603 wxPyEndAllowThreads(__tstate);
13604 if (PyErr_Occurred()) SWIG_fail;
13605 }
13606 resultobj = SWIG_Py_Void();
13607 {
13608 if (temp1)
13609 delete arg1;
13610 }
13611 return resultobj;
13612 fail:
13613 {
13614 if (temp1)
13615 delete arg1;
13616 }
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxString *arg1 = 0 ;
13624 bool temp1 = false ;
13625 PyObject * obj0 = 0 ;
13626 char * kwnames[] = {
13627 (char *) "msg", NULL
13628 };
13629
13630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13631 {
13632 arg1 = wxString_in_helper(obj0);
13633 if (arg1 == NULL) SWIG_fail;
13634 temp1 = true;
13635 }
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 wxPyLogMessage((wxString const &)*arg1);
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 resultobj = SWIG_Py_Void();
13643 {
13644 if (temp1)
13645 delete arg1;
13646 }
13647 return resultobj;
13648 fail:
13649 {
13650 if (temp1)
13651 delete arg1;
13652 }
13653 return NULL;
13654 }
13655
13656
13657 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13658 PyObject *resultobj = 0;
13659 wxString *arg1 = 0 ;
13660 bool temp1 = false ;
13661 PyObject * obj0 = 0 ;
13662 char * kwnames[] = {
13663 (char *) "msg", NULL
13664 };
13665
13666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13667 {
13668 arg1 = wxString_in_helper(obj0);
13669 if (arg1 == NULL) SWIG_fail;
13670 temp1 = true;
13671 }
13672 {
13673 PyThreadState* __tstate = wxPyBeginAllowThreads();
13674 wxPyLogInfo((wxString const &)*arg1);
13675 wxPyEndAllowThreads(__tstate);
13676 if (PyErr_Occurred()) SWIG_fail;
13677 }
13678 resultobj = SWIG_Py_Void();
13679 {
13680 if (temp1)
13681 delete arg1;
13682 }
13683 return resultobj;
13684 fail:
13685 {
13686 if (temp1)
13687 delete arg1;
13688 }
13689 return NULL;
13690 }
13691
13692
13693 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13694 PyObject *resultobj = 0;
13695 wxString *arg1 = 0 ;
13696 bool temp1 = false ;
13697 PyObject * obj0 = 0 ;
13698 char * kwnames[] = {
13699 (char *) "msg", NULL
13700 };
13701
13702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13703 {
13704 arg1 = wxString_in_helper(obj0);
13705 if (arg1 == NULL) SWIG_fail;
13706 temp1 = true;
13707 }
13708 {
13709 PyThreadState* __tstate = wxPyBeginAllowThreads();
13710 wxPyLogDebug((wxString const &)*arg1);
13711 wxPyEndAllowThreads(__tstate);
13712 if (PyErr_Occurred()) SWIG_fail;
13713 }
13714 resultobj = SWIG_Py_Void();
13715 {
13716 if (temp1)
13717 delete arg1;
13718 }
13719 return resultobj;
13720 fail:
13721 {
13722 if (temp1)
13723 delete arg1;
13724 }
13725 return NULL;
13726 }
13727
13728
13729 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13730 PyObject *resultobj = 0;
13731 wxString *arg1 = 0 ;
13732 bool temp1 = false ;
13733 PyObject * obj0 = 0 ;
13734 char * kwnames[] = {
13735 (char *) "msg", NULL
13736 };
13737
13738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13739 {
13740 arg1 = wxString_in_helper(obj0);
13741 if (arg1 == NULL) SWIG_fail;
13742 temp1 = true;
13743 }
13744 {
13745 PyThreadState* __tstate = wxPyBeginAllowThreads();
13746 wxPyLogVerbose((wxString const &)*arg1);
13747 wxPyEndAllowThreads(__tstate);
13748 if (PyErr_Occurred()) SWIG_fail;
13749 }
13750 resultobj = SWIG_Py_Void();
13751 {
13752 if (temp1)
13753 delete arg1;
13754 }
13755 return resultobj;
13756 fail:
13757 {
13758 if (temp1)
13759 delete arg1;
13760 }
13761 return NULL;
13762 }
13763
13764
13765 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13766 PyObject *resultobj = 0;
13767 wxString *arg1 = 0 ;
13768 bool temp1 = false ;
13769 PyObject * obj0 = 0 ;
13770 char * kwnames[] = {
13771 (char *) "msg", NULL
13772 };
13773
13774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13775 {
13776 arg1 = wxString_in_helper(obj0);
13777 if (arg1 == NULL) SWIG_fail;
13778 temp1 = true;
13779 }
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 wxPyLogStatus((wxString const &)*arg1);
13783 wxPyEndAllowThreads(__tstate);
13784 if (PyErr_Occurred()) SWIG_fail;
13785 }
13786 resultobj = SWIG_Py_Void();
13787 {
13788 if (temp1)
13789 delete arg1;
13790 }
13791 return resultobj;
13792 fail:
13793 {
13794 if (temp1)
13795 delete arg1;
13796 }
13797 return NULL;
13798 }
13799
13800
13801 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13802 PyObject *resultobj = 0;
13803 wxFrame *arg1 = (wxFrame *) 0 ;
13804 wxString *arg2 = 0 ;
13805 void *argp1 = 0 ;
13806 int res1 = 0 ;
13807 bool temp2 = false ;
13808 PyObject * obj0 = 0 ;
13809 PyObject * obj1 = 0 ;
13810 char * kwnames[] = {
13811 (char *) "pFrame",(char *) "msg", NULL
13812 };
13813
13814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13816 if (!SWIG_IsOK(res1)) {
13817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13818 }
13819 arg1 = reinterpret_cast< wxFrame * >(argp1);
13820 {
13821 arg2 = wxString_in_helper(obj1);
13822 if (arg2 == NULL) SWIG_fail;
13823 temp2 = true;
13824 }
13825 {
13826 PyThreadState* __tstate = wxPyBeginAllowThreads();
13827 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13828 wxPyEndAllowThreads(__tstate);
13829 if (PyErr_Occurred()) SWIG_fail;
13830 }
13831 resultobj = SWIG_Py_Void();
13832 {
13833 if (temp2)
13834 delete arg2;
13835 }
13836 return resultobj;
13837 fail:
13838 {
13839 if (temp2)
13840 delete arg2;
13841 }
13842 return NULL;
13843 }
13844
13845
13846 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13847 PyObject *resultobj = 0;
13848 wxString *arg1 = 0 ;
13849 bool temp1 = false ;
13850 PyObject * obj0 = 0 ;
13851 char * kwnames[] = {
13852 (char *) "msg", NULL
13853 };
13854
13855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13856 {
13857 arg1 = wxString_in_helper(obj0);
13858 if (arg1 == NULL) SWIG_fail;
13859 temp1 = true;
13860 }
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 wxPyLogSysError((wxString const &)*arg1);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_Py_Void();
13868 {
13869 if (temp1)
13870 delete arg1;
13871 }
13872 return resultobj;
13873 fail:
13874 {
13875 if (temp1)
13876 delete arg1;
13877 }
13878 return NULL;
13879 }
13880
13881
13882 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13883 PyObject *resultobj = 0;
13884 unsigned long arg1 ;
13885 wxString *arg2 = 0 ;
13886 unsigned long val1 ;
13887 int ecode1 = 0 ;
13888 bool temp2 = false ;
13889 PyObject * obj0 = 0 ;
13890 PyObject * obj1 = 0 ;
13891 char * kwnames[] = {
13892 (char *) "level",(char *) "msg", NULL
13893 };
13894
13895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13896 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13897 if (!SWIG_IsOK(ecode1)) {
13898 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13899 }
13900 arg1 = static_cast< unsigned long >(val1);
13901 {
13902 arg2 = wxString_in_helper(obj1);
13903 if (arg2 == NULL) SWIG_fail;
13904 temp2 = true;
13905 }
13906 {
13907 PyThreadState* __tstate = wxPyBeginAllowThreads();
13908 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13909 wxPyEndAllowThreads(__tstate);
13910 if (PyErr_Occurred()) SWIG_fail;
13911 }
13912 resultobj = SWIG_Py_Void();
13913 {
13914 if (temp2)
13915 delete arg2;
13916 }
13917 return resultobj;
13918 fail:
13919 {
13920 if (temp2)
13921 delete arg2;
13922 }
13923 return NULL;
13924 }
13925
13926
13927 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13928 PyObject *resultobj = 0;
13929 unsigned long arg1 ;
13930 wxString *arg2 = 0 ;
13931 unsigned long val1 ;
13932 int ecode1 = 0 ;
13933 bool temp2 = false ;
13934
13935 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13936 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13937 if (!SWIG_IsOK(ecode1)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13939 }
13940 arg1 = static_cast< unsigned long >(val1);
13941 {
13942 arg2 = wxString_in_helper(swig_obj[1]);
13943 if (arg2 == NULL) SWIG_fail;
13944 temp2 = true;
13945 }
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 wxPyLogTrace(arg1,(wxString const &)*arg2);
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_Py_Void();
13953 {
13954 if (temp2)
13955 delete arg2;
13956 }
13957 return resultobj;
13958 fail:
13959 {
13960 if (temp2)
13961 delete arg2;
13962 }
13963 return NULL;
13964 }
13965
13966
13967 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13968 PyObject *resultobj = 0;
13969 wxString *arg1 = 0 ;
13970 wxString *arg2 = 0 ;
13971 bool temp1 = false ;
13972 bool temp2 = false ;
13973
13974 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13975 {
13976 arg1 = wxString_in_helper(swig_obj[0]);
13977 if (arg1 == NULL) SWIG_fail;
13978 temp1 = true;
13979 }
13980 {
13981 arg2 = wxString_in_helper(swig_obj[1]);
13982 if (arg2 == NULL) SWIG_fail;
13983 temp2 = true;
13984 }
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 resultobj = SWIG_Py_Void();
13992 {
13993 if (temp1)
13994 delete arg1;
13995 }
13996 {
13997 if (temp2)
13998 delete arg2;
13999 }
14000 return resultobj;
14001 fail:
14002 {
14003 if (temp1)
14004 delete arg1;
14005 }
14006 {
14007 if (temp2)
14008 delete arg2;
14009 }
14010 return NULL;
14011 }
14012
14013
14014 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14015 int argc;
14016 PyObject *argv[3];
14017
14018 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14019 --argc;
14020 if (argc == 2) {
14021 int _v = 0;
14022 {
14023 {
14024 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14025 }
14026 }
14027 if (!_v) goto check_1;
14028 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14029 }
14030 check_1:
14031
14032 if (argc == 2) {
14033 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14034 }
14035
14036 fail:
14037 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14038 return NULL;
14039 }
14040
14041
14042 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14043 PyObject *resultobj = 0;
14044 wxString *arg1 = 0 ;
14045 wxString *arg2 = 0 ;
14046 bool temp1 = false ;
14047 bool temp2 = false ;
14048 PyObject * obj0 = 0 ;
14049 PyObject * obj1 = 0 ;
14050 char * kwnames[] = {
14051 (char *) "title",(char *) "text", NULL
14052 };
14053
14054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14055 {
14056 arg1 = wxString_in_helper(obj0);
14057 if (arg1 == NULL) SWIG_fail;
14058 temp1 = true;
14059 }
14060 {
14061 arg2 = wxString_in_helper(obj1);
14062 if (arg2 == NULL) SWIG_fail;
14063 temp2 = true;
14064 }
14065 {
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 resultobj = SWIG_Py_Void();
14072 {
14073 if (temp1)
14074 delete arg1;
14075 }
14076 {
14077 if (temp2)
14078 delete arg2;
14079 }
14080 return resultobj;
14081 fail:
14082 {
14083 if (temp1)
14084 delete arg1;
14085 }
14086 {
14087 if (temp2)
14088 delete arg2;
14089 }
14090 return NULL;
14091 }
14092
14093
14094 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14095 PyObject *resultobj = 0;
14096 wxLogNull *result = 0 ;
14097
14098 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14099 {
14100 PyThreadState* __tstate = wxPyBeginAllowThreads();
14101 result = (wxLogNull *)new wxLogNull();
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14106 return resultobj;
14107 fail:
14108 return NULL;
14109 }
14110
14111
14112 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14113 PyObject *resultobj = 0;
14114 wxLogNull *arg1 = (wxLogNull *) 0 ;
14115 void *argp1 = 0 ;
14116 int res1 = 0 ;
14117 PyObject *swig_obj[1] ;
14118
14119 if (!args) SWIG_fail;
14120 swig_obj[0] = args;
14121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14122 if (!SWIG_IsOK(res1)) {
14123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14124 }
14125 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 delete arg1;
14129
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 resultobj = SWIG_Py_Void();
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14141 PyObject *obj;
14142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14143 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14144 return SWIG_Py_Void();
14145 }
14146
14147 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14148 return SWIG_Python_InitShadowInstance(args);
14149 }
14150
14151 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14152 PyObject *resultobj = 0;
14153 wxPyLog *result = 0 ;
14154
14155 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14156 {
14157 PyThreadState* __tstate = wxPyBeginAllowThreads();
14158 result = (wxPyLog *)new wxPyLog();
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14163 return resultobj;
14164 fail:
14165 return NULL;
14166 }
14167
14168
14169 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14170 PyObject *resultobj = 0;
14171 wxPyLog *arg1 = (wxPyLog *) 0 ;
14172 PyObject *arg2 = (PyObject *) 0 ;
14173 PyObject *arg3 = (PyObject *) 0 ;
14174 void *argp1 = 0 ;
14175 int res1 = 0 ;
14176 PyObject * obj0 = 0 ;
14177 PyObject * obj1 = 0 ;
14178 PyObject * obj2 = 0 ;
14179 char * kwnames[] = {
14180 (char *) "self",(char *) "self",(char *) "_class", NULL
14181 };
14182
14183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14185 if (!SWIG_IsOK(res1)) {
14186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14187 }
14188 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14189 arg2 = obj1;
14190 arg3 = obj2;
14191 {
14192 PyThreadState* __tstate = wxPyBeginAllowThreads();
14193 (arg1)->_setCallbackInfo(arg2,arg3);
14194 wxPyEndAllowThreads(__tstate);
14195 if (PyErr_Occurred()) SWIG_fail;
14196 }
14197 resultobj = SWIG_Py_Void();
14198 return resultobj;
14199 fail:
14200 return NULL;
14201 }
14202
14203
14204 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14205 PyObject *obj;
14206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14207 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14208 return SWIG_Py_Void();
14209 }
14210
14211 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14212 return SWIG_Python_InitShadowInstance(args);
14213 }
14214
14215 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14216 PyObject *resultobj = 0;
14217 int arg1 ;
14218 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14219 int arg3 = (int) wxKILL_NOCHILDREN ;
14220 wxKillError result;
14221 int val1 ;
14222 int ecode1 = 0 ;
14223 int val2 ;
14224 int ecode2 = 0 ;
14225 int val3 ;
14226 int ecode3 = 0 ;
14227 PyObject * obj0 = 0 ;
14228 PyObject * obj1 = 0 ;
14229 PyObject * obj2 = 0 ;
14230 char * kwnames[] = {
14231 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14232 };
14233
14234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14235 ecode1 = SWIG_AsVal_int(obj0, &val1);
14236 if (!SWIG_IsOK(ecode1)) {
14237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14238 }
14239 arg1 = static_cast< int >(val1);
14240 if (obj1) {
14241 ecode2 = SWIG_AsVal_int(obj1, &val2);
14242 if (!SWIG_IsOK(ecode2)) {
14243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14244 }
14245 arg2 = static_cast< wxSignal >(val2);
14246 }
14247 if (obj2) {
14248 ecode3 = SWIG_AsVal_int(obj2, &val3);
14249 if (!SWIG_IsOK(ecode3)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14251 }
14252 arg3 = static_cast< int >(val3);
14253 }
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 resultobj = SWIG_From_int(static_cast< int >(result));
14261 return resultobj;
14262 fail:
14263 return NULL;
14264 }
14265
14266
14267 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14268 PyObject *resultobj = 0;
14269 int arg1 ;
14270 bool result;
14271 int val1 ;
14272 int ecode1 = 0 ;
14273 PyObject * obj0 = 0 ;
14274 char * kwnames[] = {
14275 (char *) "pid", NULL
14276 };
14277
14278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14279 ecode1 = SWIG_AsVal_int(obj0, &val1);
14280 if (!SWIG_IsOK(ecode1)) {
14281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14282 }
14283 arg1 = static_cast< int >(val1);
14284 {
14285 PyThreadState* __tstate = wxPyBeginAllowThreads();
14286 result = (bool)wxPyProcess::Exists(arg1);
14287 wxPyEndAllowThreads(__tstate);
14288 if (PyErr_Occurred()) SWIG_fail;
14289 }
14290 {
14291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14292 }
14293 return resultobj;
14294 fail:
14295 return NULL;
14296 }
14297
14298
14299 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14300 PyObject *resultobj = 0;
14301 wxString *arg1 = 0 ;
14302 int arg2 = (int) wxEXEC_ASYNC ;
14303 wxPyProcess *result = 0 ;
14304 bool temp1 = false ;
14305 int val2 ;
14306 int ecode2 = 0 ;
14307 PyObject * obj0 = 0 ;
14308 PyObject * obj1 = 0 ;
14309 char * kwnames[] = {
14310 (char *) "cmd",(char *) "flags", NULL
14311 };
14312
14313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14314 {
14315 arg1 = wxString_in_helper(obj0);
14316 if (arg1 == NULL) SWIG_fail;
14317 temp1 = true;
14318 }
14319 if (obj1) {
14320 ecode2 = SWIG_AsVal_int(obj1, &val2);
14321 if (!SWIG_IsOK(ecode2)) {
14322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14323 }
14324 arg2 = static_cast< int >(val2);
14325 }
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14329 wxPyEndAllowThreads(__tstate);
14330 if (PyErr_Occurred()) SWIG_fail;
14331 }
14332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14333 {
14334 if (temp1)
14335 delete arg1;
14336 }
14337 return resultobj;
14338 fail:
14339 {
14340 if (temp1)
14341 delete arg1;
14342 }
14343 return NULL;
14344 }
14345
14346
14347 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj = 0;
14349 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14350 int arg2 = (int) -1 ;
14351 wxPyProcess *result = 0 ;
14352 void *argp1 = 0 ;
14353 int res1 = 0 ;
14354 int val2 ;
14355 int ecode2 = 0 ;
14356 PyObject * obj0 = 0 ;
14357 PyObject * obj1 = 0 ;
14358 char * kwnames[] = {
14359 (char *) "parent",(char *) "id", NULL
14360 };
14361
14362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14363 if (obj0) {
14364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14365 if (!SWIG_IsOK(res1)) {
14366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14367 }
14368 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14369 }
14370 if (obj1) {
14371 ecode2 = SWIG_AsVal_int(obj1, &val2);
14372 if (!SWIG_IsOK(ecode2)) {
14373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14374 }
14375 arg2 = static_cast< int >(val2);
14376 }
14377 {
14378 PyThreadState* __tstate = wxPyBeginAllowThreads();
14379 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14384 return resultobj;
14385 fail:
14386 return NULL;
14387 }
14388
14389
14390 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14391 PyObject *resultobj = 0;
14392 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14393 PyObject *arg2 = (PyObject *) 0 ;
14394 PyObject *arg3 = (PyObject *) 0 ;
14395 void *argp1 = 0 ;
14396 int res1 = 0 ;
14397 PyObject * obj0 = 0 ;
14398 PyObject * obj1 = 0 ;
14399 PyObject * obj2 = 0 ;
14400 char * kwnames[] = {
14401 (char *) "self",(char *) "self",(char *) "_class", NULL
14402 };
14403
14404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14406 if (!SWIG_IsOK(res1)) {
14407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14408 }
14409 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14410 arg2 = obj1;
14411 arg3 = obj2;
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 (arg1)->_setCallbackInfo(arg2,arg3);
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 resultobj = SWIG_Py_Void();
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14426 PyObject *resultobj = 0;
14427 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14428 int arg2 ;
14429 int arg3 ;
14430 void *argp1 = 0 ;
14431 int res1 = 0 ;
14432 int val2 ;
14433 int ecode2 = 0 ;
14434 int val3 ;
14435 int ecode3 = 0 ;
14436 PyObject * obj0 = 0 ;
14437 PyObject * obj1 = 0 ;
14438 PyObject * obj2 = 0 ;
14439 char * kwnames[] = {
14440 (char *) "self",(char *) "pid",(char *) "status", NULL
14441 };
14442
14443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14445 if (!SWIG_IsOK(res1)) {
14446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14447 }
14448 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14449 ecode2 = SWIG_AsVal_int(obj1, &val2);
14450 if (!SWIG_IsOK(ecode2)) {
14451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14452 }
14453 arg2 = static_cast< int >(val2);
14454 ecode3 = SWIG_AsVal_int(obj2, &val3);
14455 if (!SWIG_IsOK(ecode3)) {
14456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14457 }
14458 arg3 = static_cast< int >(val3);
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 (arg1)->OnTerminate(arg2,arg3);
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 resultobj = SWIG_Py_Void();
14466 return resultobj;
14467 fail:
14468 return NULL;
14469 }
14470
14471
14472 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14473 PyObject *resultobj = 0;
14474 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14475 void *argp1 = 0 ;
14476 int res1 = 0 ;
14477 PyObject *swig_obj[1] ;
14478
14479 if (!args) SWIG_fail;
14480 swig_obj[0] = args;
14481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14482 if (!SWIG_IsOK(res1)) {
14483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14484 }
14485 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14486 {
14487 PyThreadState* __tstate = wxPyBeginAllowThreads();
14488 (arg1)->Redirect();
14489 wxPyEndAllowThreads(__tstate);
14490 if (PyErr_Occurred()) SWIG_fail;
14491 }
14492 resultobj = SWIG_Py_Void();
14493 return resultobj;
14494 fail:
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14500 PyObject *resultobj = 0;
14501 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14502 bool result;
14503 void *argp1 = 0 ;
14504 int res1 = 0 ;
14505 PyObject *swig_obj[1] ;
14506
14507 if (!args) SWIG_fail;
14508 swig_obj[0] = args;
14509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14510 if (!SWIG_IsOK(res1)) {
14511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14512 }
14513 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14514 {
14515 PyThreadState* __tstate = wxPyBeginAllowThreads();
14516 result = (bool)(arg1)->IsRedirected();
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 {
14521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14522 }
14523 return resultobj;
14524 fail:
14525 return NULL;
14526 }
14527
14528
14529 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14530 PyObject *resultobj = 0;
14531 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14532 void *argp1 = 0 ;
14533 int res1 = 0 ;
14534 PyObject *swig_obj[1] ;
14535
14536 if (!args) SWIG_fail;
14537 swig_obj[0] = args;
14538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14539 if (!SWIG_IsOK(res1)) {
14540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14541 }
14542 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 (arg1)->Detach();
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 resultobj = SWIG_Py_Void();
14550 return resultobj;
14551 fail:
14552 return NULL;
14553 }
14554
14555
14556 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14557 PyObject *resultobj = 0;
14558 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14559 wxInputStream *result = 0 ;
14560 void *argp1 = 0 ;
14561 int res1 = 0 ;
14562 PyObject *swig_obj[1] ;
14563
14564 if (!args) SWIG_fail;
14565 swig_obj[0] = args;
14566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14567 if (!SWIG_IsOK(res1)) {
14568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14569 }
14570 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14571 {
14572 PyThreadState* __tstate = wxPyBeginAllowThreads();
14573 result = (wxInputStream *)(arg1)->GetInputStream();
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 {
14578 wxPyInputStream * _ptr = NULL;
14579
14580 if (result) {
14581 _ptr = new wxPyInputStream(result);
14582 }
14583 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14584 }
14585 return resultobj;
14586 fail:
14587 return NULL;
14588 }
14589
14590
14591 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14592 PyObject *resultobj = 0;
14593 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14594 wxInputStream *result = 0 ;
14595 void *argp1 = 0 ;
14596 int res1 = 0 ;
14597 PyObject *swig_obj[1] ;
14598
14599 if (!args) SWIG_fail;
14600 swig_obj[0] = args;
14601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14602 if (!SWIG_IsOK(res1)) {
14603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14604 }
14605 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14606 {
14607 PyThreadState* __tstate = wxPyBeginAllowThreads();
14608 result = (wxInputStream *)(arg1)->GetErrorStream();
14609 wxPyEndAllowThreads(__tstate);
14610 if (PyErr_Occurred()) SWIG_fail;
14611 }
14612 {
14613 wxPyInputStream * _ptr = NULL;
14614
14615 if (result) {
14616 _ptr = new wxPyInputStream(result);
14617 }
14618 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14619 }
14620 return resultobj;
14621 fail:
14622 return NULL;
14623 }
14624
14625
14626 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14627 PyObject *resultobj = 0;
14628 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14629 wxOutputStream *result = 0 ;
14630 void *argp1 = 0 ;
14631 int res1 = 0 ;
14632 PyObject *swig_obj[1] ;
14633
14634 if (!args) SWIG_fail;
14635 swig_obj[0] = args;
14636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14637 if (!SWIG_IsOK(res1)) {
14638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14639 }
14640 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14641 {
14642 PyThreadState* __tstate = wxPyBeginAllowThreads();
14643 result = (wxOutputStream *)(arg1)->GetOutputStream();
14644 wxPyEndAllowThreads(__tstate);
14645 if (PyErr_Occurred()) SWIG_fail;
14646 }
14647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14648 return resultobj;
14649 fail:
14650 return NULL;
14651 }
14652
14653
14654 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14655 PyObject *resultobj = 0;
14656 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14657 void *argp1 = 0 ;
14658 int res1 = 0 ;
14659 PyObject *swig_obj[1] ;
14660
14661 if (!args) SWIG_fail;
14662 swig_obj[0] = args;
14663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14664 if (!SWIG_IsOK(res1)) {
14665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14666 }
14667 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14668 {
14669 PyThreadState* __tstate = wxPyBeginAllowThreads();
14670 (arg1)->CloseOutput();
14671 wxPyEndAllowThreads(__tstate);
14672 if (PyErr_Occurred()) SWIG_fail;
14673 }
14674 resultobj = SWIG_Py_Void();
14675 return resultobj;
14676 fail:
14677 return NULL;
14678 }
14679
14680
14681 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14682 PyObject *resultobj = 0;
14683 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14684 bool result;
14685 void *argp1 = 0 ;
14686 int res1 = 0 ;
14687 PyObject *swig_obj[1] ;
14688
14689 if (!args) SWIG_fail;
14690 swig_obj[0] = args;
14691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14692 if (!SWIG_IsOK(res1)) {
14693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14694 }
14695 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14696 {
14697 PyThreadState* __tstate = wxPyBeginAllowThreads();
14698 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14699 wxPyEndAllowThreads(__tstate);
14700 if (PyErr_Occurred()) SWIG_fail;
14701 }
14702 {
14703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14704 }
14705 return resultobj;
14706 fail:
14707 return NULL;
14708 }
14709
14710
14711 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14712 PyObject *resultobj = 0;
14713 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14714 bool result;
14715 void *argp1 = 0 ;
14716 int res1 = 0 ;
14717 PyObject *swig_obj[1] ;
14718
14719 if (!args) SWIG_fail;
14720 swig_obj[0] = args;
14721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14722 if (!SWIG_IsOK(res1)) {
14723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14724 }
14725 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14726 {
14727 PyThreadState* __tstate = wxPyBeginAllowThreads();
14728 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14729 wxPyEndAllowThreads(__tstate);
14730 if (PyErr_Occurred()) SWIG_fail;
14731 }
14732 {
14733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14734 }
14735 return resultobj;
14736 fail:
14737 return NULL;
14738 }
14739
14740
14741 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14742 PyObject *resultobj = 0;
14743 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14744 bool result;
14745 void *argp1 = 0 ;
14746 int res1 = 0 ;
14747 PyObject *swig_obj[1] ;
14748
14749 if (!args) SWIG_fail;
14750 swig_obj[0] = args;
14751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14752 if (!SWIG_IsOK(res1)) {
14753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14754 }
14755 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14756 {
14757 PyThreadState* __tstate = wxPyBeginAllowThreads();
14758 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14759 wxPyEndAllowThreads(__tstate);
14760 if (PyErr_Occurred()) SWIG_fail;
14761 }
14762 {
14763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14764 }
14765 return resultobj;
14766 fail:
14767 return NULL;
14768 }
14769
14770
14771 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14772 PyObject *obj;
14773 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14774 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14775 return SWIG_Py_Void();
14776 }
14777
14778 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14779 return SWIG_Python_InitShadowInstance(args);
14780 }
14781
14782 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14783 PyObject *resultobj = 0;
14784 int arg1 = (int) 0 ;
14785 int arg2 = (int) 0 ;
14786 int arg3 = (int) 0 ;
14787 wxProcessEvent *result = 0 ;
14788 int val1 ;
14789 int ecode1 = 0 ;
14790 int val2 ;
14791 int ecode2 = 0 ;
14792 int val3 ;
14793 int ecode3 = 0 ;
14794 PyObject * obj0 = 0 ;
14795 PyObject * obj1 = 0 ;
14796 PyObject * obj2 = 0 ;
14797 char * kwnames[] = {
14798 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14799 };
14800
14801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14802 if (obj0) {
14803 ecode1 = SWIG_AsVal_int(obj0, &val1);
14804 if (!SWIG_IsOK(ecode1)) {
14805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14806 }
14807 arg1 = static_cast< int >(val1);
14808 }
14809 if (obj1) {
14810 ecode2 = SWIG_AsVal_int(obj1, &val2);
14811 if (!SWIG_IsOK(ecode2)) {
14812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14813 }
14814 arg2 = static_cast< int >(val2);
14815 }
14816 if (obj2) {
14817 ecode3 = SWIG_AsVal_int(obj2, &val3);
14818 if (!SWIG_IsOK(ecode3)) {
14819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14820 }
14821 arg3 = static_cast< int >(val3);
14822 }
14823 {
14824 PyThreadState* __tstate = wxPyBeginAllowThreads();
14825 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14826 wxPyEndAllowThreads(__tstate);
14827 if (PyErr_Occurred()) SWIG_fail;
14828 }
14829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14830 return resultobj;
14831 fail:
14832 return NULL;
14833 }
14834
14835
14836 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14837 PyObject *resultobj = 0;
14838 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14839 int result;
14840 void *argp1 = 0 ;
14841 int res1 = 0 ;
14842 PyObject *swig_obj[1] ;
14843
14844 if (!args) SWIG_fail;
14845 swig_obj[0] = args;
14846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14847 if (!SWIG_IsOK(res1)) {
14848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14849 }
14850 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (int)(arg1)->GetPid();
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 resultobj = SWIG_From_int(static_cast< int >(result));
14858 return resultobj;
14859 fail:
14860 return NULL;
14861 }
14862
14863
14864 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14865 PyObject *resultobj = 0;
14866 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14867 int result;
14868 void *argp1 = 0 ;
14869 int res1 = 0 ;
14870 PyObject *swig_obj[1] ;
14871
14872 if (!args) SWIG_fail;
14873 swig_obj[0] = args;
14874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14875 if (!SWIG_IsOK(res1)) {
14876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14877 }
14878 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14879 {
14880 PyThreadState* __tstate = wxPyBeginAllowThreads();
14881 result = (int)(arg1)->GetExitCode();
14882 wxPyEndAllowThreads(__tstate);
14883 if (PyErr_Occurred()) SWIG_fail;
14884 }
14885 resultobj = SWIG_From_int(static_cast< int >(result));
14886 return resultobj;
14887 fail:
14888 return NULL;
14889 }
14890
14891
14892 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14893 PyObject *resultobj = 0;
14894 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14895 int arg2 ;
14896 void *argp1 = 0 ;
14897 int res1 = 0 ;
14898 int val2 ;
14899 int ecode2 = 0 ;
14900 PyObject *swig_obj[2] ;
14901
14902 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14904 if (!SWIG_IsOK(res1)) {
14905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14906 }
14907 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14908 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14909 if (!SWIG_IsOK(ecode2)) {
14910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14911 }
14912 arg2 = static_cast< int >(val2);
14913 if (arg1) (arg1)->m_pid = arg2;
14914
14915 resultobj = SWIG_Py_Void();
14916 return resultobj;
14917 fail:
14918 return NULL;
14919 }
14920
14921
14922 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14923 PyObject *resultobj = 0;
14924 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14925 int result;
14926 void *argp1 = 0 ;
14927 int res1 = 0 ;
14928 PyObject *swig_obj[1] ;
14929
14930 if (!args) SWIG_fail;
14931 swig_obj[0] = args;
14932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14933 if (!SWIG_IsOK(res1)) {
14934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14935 }
14936 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14937 result = (int) ((arg1)->m_pid);
14938 resultobj = SWIG_From_int(static_cast< int >(result));
14939 return resultobj;
14940 fail:
14941 return NULL;
14942 }
14943
14944
14945 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14946 PyObject *resultobj = 0;
14947 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14948 int arg2 ;
14949 void *argp1 = 0 ;
14950 int res1 = 0 ;
14951 int val2 ;
14952 int ecode2 = 0 ;
14953 PyObject *swig_obj[2] ;
14954
14955 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14957 if (!SWIG_IsOK(res1)) {
14958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14959 }
14960 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14961 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14962 if (!SWIG_IsOK(ecode2)) {
14963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14964 }
14965 arg2 = static_cast< int >(val2);
14966 if (arg1) (arg1)->m_exitcode = arg2;
14967
14968 resultobj = SWIG_Py_Void();
14969 return resultobj;
14970 fail:
14971 return NULL;
14972 }
14973
14974
14975 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14976 PyObject *resultobj = 0;
14977 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14978 int result;
14979 void *argp1 = 0 ;
14980 int res1 = 0 ;
14981 PyObject *swig_obj[1] ;
14982
14983 if (!args) SWIG_fail;
14984 swig_obj[0] = args;
14985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14986 if (!SWIG_IsOK(res1)) {
14987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14988 }
14989 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14990 result = (int) ((arg1)->m_exitcode);
14991 resultobj = SWIG_From_int(static_cast< int >(result));
14992 return resultobj;
14993 fail:
14994 return NULL;
14995 }
14996
14997
14998 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14999 PyObject *obj;
15000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15001 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15002 return SWIG_Py_Void();
15003 }
15004
15005 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15006 return SWIG_Python_InitShadowInstance(args);
15007 }
15008
15009 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15010 PyObject *resultobj = 0;
15011 wxString *arg1 = 0 ;
15012 int arg2 = (int) wxEXEC_ASYNC ;
15013 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15014 long result;
15015 bool temp1 = false ;
15016 int val2 ;
15017 int ecode2 = 0 ;
15018 void *argp3 = 0 ;
15019 int res3 = 0 ;
15020 PyObject * obj0 = 0 ;
15021 PyObject * obj1 = 0 ;
15022 PyObject * obj2 = 0 ;
15023 char * kwnames[] = {
15024 (char *) "command",(char *) "flags",(char *) "process", NULL
15025 };
15026
15027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15028 {
15029 arg1 = wxString_in_helper(obj0);
15030 if (arg1 == NULL) SWIG_fail;
15031 temp1 = true;
15032 }
15033 if (obj1) {
15034 ecode2 = SWIG_AsVal_int(obj1, &val2);
15035 if (!SWIG_IsOK(ecode2)) {
15036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15037 }
15038 arg2 = static_cast< int >(val2);
15039 }
15040 if (obj2) {
15041 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15042 if (!SWIG_IsOK(res3)) {
15043 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15044 }
15045 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15046 }
15047 {
15048 if (!wxPyCheckForApp()) SWIG_fail;
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 resultobj = SWIG_From_long(static_cast< long >(result));
15055 {
15056 if (temp1)
15057 delete arg1;
15058 }
15059 return resultobj;
15060 fail:
15061 {
15062 if (temp1)
15063 delete arg1;
15064 }
15065 return NULL;
15066 }
15067
15068
15069 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15070 PyObject *resultobj = 0;
15071 long arg1 ;
15072 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15073 wxKillError *arg3 = (wxKillError *) 0 ;
15074 int arg4 = (int) wxKILL_NOCHILDREN ;
15075 int result;
15076 long val1 ;
15077 int ecode1 = 0 ;
15078 int val2 ;
15079 int ecode2 = 0 ;
15080 wxKillError temp3 ;
15081 int val4 ;
15082 int ecode4 = 0 ;
15083 PyObject * obj0 = 0 ;
15084 PyObject * obj1 = 0 ;
15085 PyObject * obj2 = 0 ;
15086 char * kwnames[] = {
15087 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15088 };
15089
15090 {
15091 arg3 = &temp3;
15092 }
15093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15094 ecode1 = SWIG_AsVal_long(obj0, &val1);
15095 if (!SWIG_IsOK(ecode1)) {
15096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15097 }
15098 arg1 = static_cast< long >(val1);
15099 if (obj1) {
15100 ecode2 = SWIG_AsVal_int(obj1, &val2);
15101 if (!SWIG_IsOK(ecode2)) {
15102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15103 }
15104 arg2 = static_cast< wxSignal >(val2);
15105 }
15106 if (obj2) {
15107 ecode4 = SWIG_AsVal_int(obj2, &val4);
15108 if (!SWIG_IsOK(ecode4)) {
15109 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15110 }
15111 arg4 = static_cast< int >(val4);
15112 }
15113 {
15114 PyThreadState* __tstate = wxPyBeginAllowThreads();
15115 result = (int)wxKill(arg1,arg2,arg3,arg4);
15116 wxPyEndAllowThreads(__tstate);
15117 if (PyErr_Occurred()) SWIG_fail;
15118 }
15119 resultobj = SWIG_From_int(static_cast< int >(result));
15120 {
15121 PyObject* o;
15122 o = PyInt_FromLong((long) (*arg3));
15123
15124
15125
15126 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15127
15128 }
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15136 PyObject *resultobj = 0;
15137 int arg1 = (int) wxJOYSTICK1 ;
15138 wxJoystick *result = 0 ;
15139 int val1 ;
15140 int ecode1 = 0 ;
15141 PyObject * obj0 = 0 ;
15142 char * kwnames[] = {
15143 (char *) "joystick", NULL
15144 };
15145
15146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15147 if (obj0) {
15148 ecode1 = SWIG_AsVal_int(obj0, &val1);
15149 if (!SWIG_IsOK(ecode1)) {
15150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15151 }
15152 arg1 = static_cast< int >(val1);
15153 }
15154 {
15155 if (!wxPyCheckForApp()) SWIG_fail;
15156 PyThreadState* __tstate = wxPyBeginAllowThreads();
15157 result = (wxJoystick *)new wxJoystick(arg1);
15158 wxPyEndAllowThreads(__tstate);
15159 if (PyErr_Occurred()) SWIG_fail;
15160 }
15161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15169 PyObject *resultobj = 0;
15170 wxJoystick *arg1 = (wxJoystick *) 0 ;
15171 void *argp1 = 0 ;
15172 int res1 = 0 ;
15173 PyObject *swig_obj[1] ;
15174
15175 if (!args) SWIG_fail;
15176 swig_obj[0] = args;
15177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15178 if (!SWIG_IsOK(res1)) {
15179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15180 }
15181 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15182 {
15183 PyThreadState* __tstate = wxPyBeginAllowThreads();
15184 delete arg1;
15185
15186 wxPyEndAllowThreads(__tstate);
15187 if (PyErr_Occurred()) SWIG_fail;
15188 }
15189 resultobj = SWIG_Py_Void();
15190 return resultobj;
15191 fail:
15192 return NULL;
15193 }
15194
15195
15196 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15197 PyObject *resultobj = 0;
15198 wxJoystick *arg1 = (wxJoystick *) 0 ;
15199 wxPoint result;
15200 void *argp1 = 0 ;
15201 int res1 = 0 ;
15202 PyObject *swig_obj[1] ;
15203
15204 if (!args) SWIG_fail;
15205 swig_obj[0] = args;
15206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15207 if (!SWIG_IsOK(res1)) {
15208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15209 }
15210 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15211 {
15212 PyThreadState* __tstate = wxPyBeginAllowThreads();
15213 result = (arg1)->GetPosition();
15214 wxPyEndAllowThreads(__tstate);
15215 if (PyErr_Occurred()) SWIG_fail;
15216 }
15217 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15218 return resultobj;
15219 fail:
15220 return NULL;
15221 }
15222
15223
15224 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15225 PyObject *resultobj = 0;
15226 wxJoystick *arg1 = (wxJoystick *) 0 ;
15227 int result;
15228 void *argp1 = 0 ;
15229 int res1 = 0 ;
15230 PyObject *swig_obj[1] ;
15231
15232 if (!args) SWIG_fail;
15233 swig_obj[0] = args;
15234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15235 if (!SWIG_IsOK(res1)) {
15236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15237 }
15238 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15239 {
15240 PyThreadState* __tstate = wxPyBeginAllowThreads();
15241 result = (int)(arg1)->GetZPosition();
15242 wxPyEndAllowThreads(__tstate);
15243 if (PyErr_Occurred()) SWIG_fail;
15244 }
15245 resultobj = SWIG_From_int(static_cast< int >(result));
15246 return resultobj;
15247 fail:
15248 return NULL;
15249 }
15250
15251
15252 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15253 PyObject *resultobj = 0;
15254 wxJoystick *arg1 = (wxJoystick *) 0 ;
15255 int result;
15256 void *argp1 = 0 ;
15257 int res1 = 0 ;
15258 PyObject *swig_obj[1] ;
15259
15260 if (!args) SWIG_fail;
15261 swig_obj[0] = args;
15262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15263 if (!SWIG_IsOK(res1)) {
15264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15265 }
15266 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15267 {
15268 PyThreadState* __tstate = wxPyBeginAllowThreads();
15269 result = (int)(arg1)->GetButtonState();
15270 wxPyEndAllowThreads(__tstate);
15271 if (PyErr_Occurred()) SWIG_fail;
15272 }
15273 resultobj = SWIG_From_int(static_cast< int >(result));
15274 return resultobj;
15275 fail:
15276 return NULL;
15277 }
15278
15279
15280 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15281 PyObject *resultobj = 0;
15282 wxJoystick *arg1 = (wxJoystick *) 0 ;
15283 int result;
15284 void *argp1 = 0 ;
15285 int res1 = 0 ;
15286 PyObject *swig_obj[1] ;
15287
15288 if (!args) SWIG_fail;
15289 swig_obj[0] = args;
15290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15291 if (!SWIG_IsOK(res1)) {
15292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15293 }
15294 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (int)(arg1)->GetPOVPosition();
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 resultobj = SWIG_From_int(static_cast< int >(result));
15302 return resultobj;
15303 fail:
15304 return NULL;
15305 }
15306
15307
15308 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15309 PyObject *resultobj = 0;
15310 wxJoystick *arg1 = (wxJoystick *) 0 ;
15311 int result;
15312 void *argp1 = 0 ;
15313 int res1 = 0 ;
15314 PyObject *swig_obj[1] ;
15315
15316 if (!args) SWIG_fail;
15317 swig_obj[0] = args;
15318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15319 if (!SWIG_IsOK(res1)) {
15320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15321 }
15322 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15323 {
15324 PyThreadState* __tstate = wxPyBeginAllowThreads();
15325 result = (int)(arg1)->GetPOVCTSPosition();
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 resultobj = SWIG_From_int(static_cast< int >(result));
15330 return resultobj;
15331 fail:
15332 return NULL;
15333 }
15334
15335
15336 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15337 PyObject *resultobj = 0;
15338 wxJoystick *arg1 = (wxJoystick *) 0 ;
15339 int result;
15340 void *argp1 = 0 ;
15341 int res1 = 0 ;
15342 PyObject *swig_obj[1] ;
15343
15344 if (!args) SWIG_fail;
15345 swig_obj[0] = args;
15346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15347 if (!SWIG_IsOK(res1)) {
15348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15349 }
15350 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15351 {
15352 PyThreadState* __tstate = wxPyBeginAllowThreads();
15353 result = (int)(arg1)->GetRudderPosition();
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 resultobj = SWIG_From_int(static_cast< int >(result));
15358 return resultobj;
15359 fail:
15360 return NULL;
15361 }
15362
15363
15364 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15365 PyObject *resultobj = 0;
15366 wxJoystick *arg1 = (wxJoystick *) 0 ;
15367 int result;
15368 void *argp1 = 0 ;
15369 int res1 = 0 ;
15370 PyObject *swig_obj[1] ;
15371
15372 if (!args) SWIG_fail;
15373 swig_obj[0] = args;
15374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15375 if (!SWIG_IsOK(res1)) {
15376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15377 }
15378 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15379 {
15380 PyThreadState* __tstate = wxPyBeginAllowThreads();
15381 result = (int)(arg1)->GetUPosition();
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 resultobj = SWIG_From_int(static_cast< int >(result));
15386 return resultobj;
15387 fail:
15388 return NULL;
15389 }
15390
15391
15392 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15393 PyObject *resultobj = 0;
15394 wxJoystick *arg1 = (wxJoystick *) 0 ;
15395 int result;
15396 void *argp1 = 0 ;
15397 int res1 = 0 ;
15398 PyObject *swig_obj[1] ;
15399
15400 if (!args) SWIG_fail;
15401 swig_obj[0] = args;
15402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15403 if (!SWIG_IsOK(res1)) {
15404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15405 }
15406 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 result = (int)(arg1)->GetVPosition();
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 resultobj = SWIG_From_int(static_cast< int >(result));
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15421 PyObject *resultobj = 0;
15422 wxJoystick *arg1 = (wxJoystick *) 0 ;
15423 int result;
15424 void *argp1 = 0 ;
15425 int res1 = 0 ;
15426 PyObject *swig_obj[1] ;
15427
15428 if (!args) SWIG_fail;
15429 swig_obj[0] = args;
15430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15431 if (!SWIG_IsOK(res1)) {
15432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15433 }
15434 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 result = (int)(arg1)->GetMovementThreshold();
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 resultobj = SWIG_From_int(static_cast< int >(result));
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15449 PyObject *resultobj = 0;
15450 wxJoystick *arg1 = (wxJoystick *) 0 ;
15451 int arg2 ;
15452 void *argp1 = 0 ;
15453 int res1 = 0 ;
15454 int val2 ;
15455 int ecode2 = 0 ;
15456 PyObject * obj0 = 0 ;
15457 PyObject * obj1 = 0 ;
15458 char * kwnames[] = {
15459 (char *) "self",(char *) "threshold", NULL
15460 };
15461
15462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15464 if (!SWIG_IsOK(res1)) {
15465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15466 }
15467 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15468 ecode2 = SWIG_AsVal_int(obj1, &val2);
15469 if (!SWIG_IsOK(ecode2)) {
15470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15471 }
15472 arg2 = static_cast< int >(val2);
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 (arg1)->SetMovementThreshold(arg2);
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = SWIG_Py_Void();
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15487 PyObject *resultobj = 0;
15488 wxJoystick *arg1 = (wxJoystick *) 0 ;
15489 bool result;
15490 void *argp1 = 0 ;
15491 int res1 = 0 ;
15492 PyObject *swig_obj[1] ;
15493
15494 if (!args) SWIG_fail;
15495 swig_obj[0] = args;
15496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15497 if (!SWIG_IsOK(res1)) {
15498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15499 }
15500 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15501 {
15502 PyThreadState* __tstate = wxPyBeginAllowThreads();
15503 result = (bool)(arg1)->IsOk();
15504 wxPyEndAllowThreads(__tstate);
15505 if (PyErr_Occurred()) SWIG_fail;
15506 }
15507 {
15508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15509 }
15510 return resultobj;
15511 fail:
15512 return NULL;
15513 }
15514
15515
15516 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15517 PyObject *resultobj = 0;
15518 wxJoystick *arg1 = (wxJoystick *) 0 ;
15519 int result;
15520 void *argp1 = 0 ;
15521 int res1 = 0 ;
15522 PyObject *swig_obj[1] ;
15523
15524 if (!args) SWIG_fail;
15525 swig_obj[0] = args;
15526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15527 if (!SWIG_IsOK(res1)) {
15528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15529 }
15530 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15531 {
15532 PyThreadState* __tstate = wxPyBeginAllowThreads();
15533 result = (int)(arg1)->GetNumberJoysticks();
15534 wxPyEndAllowThreads(__tstate);
15535 if (PyErr_Occurred()) SWIG_fail;
15536 }
15537 resultobj = SWIG_From_int(static_cast< int >(result));
15538 return resultobj;
15539 fail:
15540 return NULL;
15541 }
15542
15543
15544 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15545 PyObject *resultobj = 0;
15546 wxJoystick *arg1 = (wxJoystick *) 0 ;
15547 int result;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 PyObject *swig_obj[1] ;
15551
15552 if (!args) SWIG_fail;
15553 swig_obj[0] = args;
15554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15555 if (!SWIG_IsOK(res1)) {
15556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15557 }
15558 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 result = (int)(arg1)->GetManufacturerId();
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_From_int(static_cast< int >(result));
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15573 PyObject *resultobj = 0;
15574 wxJoystick *arg1 = (wxJoystick *) 0 ;
15575 int result;
15576 void *argp1 = 0 ;
15577 int res1 = 0 ;
15578 PyObject *swig_obj[1] ;
15579
15580 if (!args) SWIG_fail;
15581 swig_obj[0] = args;
15582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15583 if (!SWIG_IsOK(res1)) {
15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15585 }
15586 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15587 {
15588 PyThreadState* __tstate = wxPyBeginAllowThreads();
15589 result = (int)(arg1)->GetProductId();
15590 wxPyEndAllowThreads(__tstate);
15591 if (PyErr_Occurred()) SWIG_fail;
15592 }
15593 resultobj = SWIG_From_int(static_cast< int >(result));
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15601 PyObject *resultobj = 0;
15602 wxJoystick *arg1 = (wxJoystick *) 0 ;
15603 wxString result;
15604 void *argp1 = 0 ;
15605 int res1 = 0 ;
15606 PyObject *swig_obj[1] ;
15607
15608 if (!args) SWIG_fail;
15609 swig_obj[0] = args;
15610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15611 if (!SWIG_IsOK(res1)) {
15612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15613 }
15614 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15615 {
15616 PyThreadState* __tstate = wxPyBeginAllowThreads();
15617 result = (arg1)->GetProductName();
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 {
15622 #if wxUSE_UNICODE
15623 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15624 #else
15625 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15626 #endif
15627 }
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15635 PyObject *resultobj = 0;
15636 wxJoystick *arg1 = (wxJoystick *) 0 ;
15637 int result;
15638 void *argp1 = 0 ;
15639 int res1 = 0 ;
15640 PyObject *swig_obj[1] ;
15641
15642 if (!args) SWIG_fail;
15643 swig_obj[0] = args;
15644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15645 if (!SWIG_IsOK(res1)) {
15646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15647 }
15648 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 result = (int)(arg1)->GetXMin();
15652 wxPyEndAllowThreads(__tstate);
15653 if (PyErr_Occurred()) SWIG_fail;
15654 }
15655 resultobj = SWIG_From_int(static_cast< int >(result));
15656 return resultobj;
15657 fail:
15658 return NULL;
15659 }
15660
15661
15662 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15663 PyObject *resultobj = 0;
15664 wxJoystick *arg1 = (wxJoystick *) 0 ;
15665 int result;
15666 void *argp1 = 0 ;
15667 int res1 = 0 ;
15668 PyObject *swig_obj[1] ;
15669
15670 if (!args) SWIG_fail;
15671 swig_obj[0] = args;
15672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15673 if (!SWIG_IsOK(res1)) {
15674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15675 }
15676 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15677 {
15678 PyThreadState* __tstate = wxPyBeginAllowThreads();
15679 result = (int)(arg1)->GetYMin();
15680 wxPyEndAllowThreads(__tstate);
15681 if (PyErr_Occurred()) SWIG_fail;
15682 }
15683 resultobj = SWIG_From_int(static_cast< int >(result));
15684 return resultobj;
15685 fail:
15686 return NULL;
15687 }
15688
15689
15690 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15691 PyObject *resultobj = 0;
15692 wxJoystick *arg1 = (wxJoystick *) 0 ;
15693 int result;
15694 void *argp1 = 0 ;
15695 int res1 = 0 ;
15696 PyObject *swig_obj[1] ;
15697
15698 if (!args) SWIG_fail;
15699 swig_obj[0] = args;
15700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15701 if (!SWIG_IsOK(res1)) {
15702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15703 }
15704 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 result = (int)(arg1)->GetZMin();
15708 wxPyEndAllowThreads(__tstate);
15709 if (PyErr_Occurred()) SWIG_fail;
15710 }
15711 resultobj = SWIG_From_int(static_cast< int >(result));
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15719 PyObject *resultobj = 0;
15720 wxJoystick *arg1 = (wxJoystick *) 0 ;
15721 int result;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 PyObject *swig_obj[1] ;
15725
15726 if (!args) SWIG_fail;
15727 swig_obj[0] = args;
15728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15729 if (!SWIG_IsOK(res1)) {
15730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15731 }
15732 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (int)(arg1)->GetXMax();
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_From_int(static_cast< int >(result));
15740 return resultobj;
15741 fail:
15742 return NULL;
15743 }
15744
15745
15746 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15747 PyObject *resultobj = 0;
15748 wxJoystick *arg1 = (wxJoystick *) 0 ;
15749 int result;
15750 void *argp1 = 0 ;
15751 int res1 = 0 ;
15752 PyObject *swig_obj[1] ;
15753
15754 if (!args) SWIG_fail;
15755 swig_obj[0] = args;
15756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15757 if (!SWIG_IsOK(res1)) {
15758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15759 }
15760 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15761 {
15762 PyThreadState* __tstate = wxPyBeginAllowThreads();
15763 result = (int)(arg1)->GetYMax();
15764 wxPyEndAllowThreads(__tstate);
15765 if (PyErr_Occurred()) SWIG_fail;
15766 }
15767 resultobj = SWIG_From_int(static_cast< int >(result));
15768 return resultobj;
15769 fail:
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15775 PyObject *resultobj = 0;
15776 wxJoystick *arg1 = (wxJoystick *) 0 ;
15777 int result;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 PyObject *swig_obj[1] ;
15781
15782 if (!args) SWIG_fail;
15783 swig_obj[0] = args;
15784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15785 if (!SWIG_IsOK(res1)) {
15786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15787 }
15788 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (int)(arg1)->GetZMax();
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 resultobj = SWIG_From_int(static_cast< int >(result));
15796 return resultobj;
15797 fail:
15798 return NULL;
15799 }
15800
15801
15802 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15803 PyObject *resultobj = 0;
15804 wxJoystick *arg1 = (wxJoystick *) 0 ;
15805 int result;
15806 void *argp1 = 0 ;
15807 int res1 = 0 ;
15808 PyObject *swig_obj[1] ;
15809
15810 if (!args) SWIG_fail;
15811 swig_obj[0] = args;
15812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15813 if (!SWIG_IsOK(res1)) {
15814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15815 }
15816 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (int)(arg1)->GetNumberButtons();
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_From_int(static_cast< int >(result));
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15831 PyObject *resultobj = 0;
15832 wxJoystick *arg1 = (wxJoystick *) 0 ;
15833 int result;
15834 void *argp1 = 0 ;
15835 int res1 = 0 ;
15836 PyObject *swig_obj[1] ;
15837
15838 if (!args) SWIG_fail;
15839 swig_obj[0] = args;
15840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15841 if (!SWIG_IsOK(res1)) {
15842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15843 }
15844 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15845 {
15846 PyThreadState* __tstate = wxPyBeginAllowThreads();
15847 result = (int)(arg1)->GetNumberAxes();
15848 wxPyEndAllowThreads(__tstate);
15849 if (PyErr_Occurred()) SWIG_fail;
15850 }
15851 resultobj = SWIG_From_int(static_cast< int >(result));
15852 return resultobj;
15853 fail:
15854 return NULL;
15855 }
15856
15857
15858 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15859 PyObject *resultobj = 0;
15860 wxJoystick *arg1 = (wxJoystick *) 0 ;
15861 int result;
15862 void *argp1 = 0 ;
15863 int res1 = 0 ;
15864 PyObject *swig_obj[1] ;
15865
15866 if (!args) SWIG_fail;
15867 swig_obj[0] = args;
15868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15869 if (!SWIG_IsOK(res1)) {
15870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15871 }
15872 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15873 {
15874 PyThreadState* __tstate = wxPyBeginAllowThreads();
15875 result = (int)(arg1)->GetMaxButtons();
15876 wxPyEndAllowThreads(__tstate);
15877 if (PyErr_Occurred()) SWIG_fail;
15878 }
15879 resultobj = SWIG_From_int(static_cast< int >(result));
15880 return resultobj;
15881 fail:
15882 return NULL;
15883 }
15884
15885
15886 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15887 PyObject *resultobj = 0;
15888 wxJoystick *arg1 = (wxJoystick *) 0 ;
15889 int result;
15890 void *argp1 = 0 ;
15891 int res1 = 0 ;
15892 PyObject *swig_obj[1] ;
15893
15894 if (!args) SWIG_fail;
15895 swig_obj[0] = args;
15896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15897 if (!SWIG_IsOK(res1)) {
15898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15899 }
15900 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (int)(arg1)->GetMaxAxes();
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_From_int(static_cast< int >(result));
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15915 PyObject *resultobj = 0;
15916 wxJoystick *arg1 = (wxJoystick *) 0 ;
15917 int result;
15918 void *argp1 = 0 ;
15919 int res1 = 0 ;
15920 PyObject *swig_obj[1] ;
15921
15922 if (!args) SWIG_fail;
15923 swig_obj[0] = args;
15924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15925 if (!SWIG_IsOK(res1)) {
15926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15927 }
15928 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15929 {
15930 PyThreadState* __tstate = wxPyBeginAllowThreads();
15931 result = (int)(arg1)->GetPollingMin();
15932 wxPyEndAllowThreads(__tstate);
15933 if (PyErr_Occurred()) SWIG_fail;
15934 }
15935 resultobj = SWIG_From_int(static_cast< int >(result));
15936 return resultobj;
15937 fail:
15938 return NULL;
15939 }
15940
15941
15942 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15943 PyObject *resultobj = 0;
15944 wxJoystick *arg1 = (wxJoystick *) 0 ;
15945 int result;
15946 void *argp1 = 0 ;
15947 int res1 = 0 ;
15948 PyObject *swig_obj[1] ;
15949
15950 if (!args) SWIG_fail;
15951 swig_obj[0] = args;
15952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15953 if (!SWIG_IsOK(res1)) {
15954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15955 }
15956 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 result = (int)(arg1)->GetPollingMax();
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 resultobj = SWIG_From_int(static_cast< int >(result));
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971 PyObject *resultobj = 0;
15972 wxJoystick *arg1 = (wxJoystick *) 0 ;
15973 int result;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 PyObject *swig_obj[1] ;
15977
15978 if (!args) SWIG_fail;
15979 swig_obj[0] = args;
15980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15981 if (!SWIG_IsOK(res1)) {
15982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15983 }
15984 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15985 {
15986 PyThreadState* __tstate = wxPyBeginAllowThreads();
15987 result = (int)(arg1)->GetRudderMin();
15988 wxPyEndAllowThreads(__tstate);
15989 if (PyErr_Occurred()) SWIG_fail;
15990 }
15991 resultobj = SWIG_From_int(static_cast< int >(result));
15992 return resultobj;
15993 fail:
15994 return NULL;
15995 }
15996
15997
15998 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15999 PyObject *resultobj = 0;
16000 wxJoystick *arg1 = (wxJoystick *) 0 ;
16001 int result;
16002 void *argp1 = 0 ;
16003 int res1 = 0 ;
16004 PyObject *swig_obj[1] ;
16005
16006 if (!args) SWIG_fail;
16007 swig_obj[0] = args;
16008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16009 if (!SWIG_IsOK(res1)) {
16010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16011 }
16012 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (int)(arg1)->GetRudderMax();
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 resultobj = SWIG_From_int(static_cast< int >(result));
16020 return resultobj;
16021 fail:
16022 return NULL;
16023 }
16024
16025
16026 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16027 PyObject *resultobj = 0;
16028 wxJoystick *arg1 = (wxJoystick *) 0 ;
16029 int result;
16030 void *argp1 = 0 ;
16031 int res1 = 0 ;
16032 PyObject *swig_obj[1] ;
16033
16034 if (!args) SWIG_fail;
16035 swig_obj[0] = args;
16036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16037 if (!SWIG_IsOK(res1)) {
16038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16039 }
16040 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16041 {
16042 PyThreadState* __tstate = wxPyBeginAllowThreads();
16043 result = (int)(arg1)->GetUMin();
16044 wxPyEndAllowThreads(__tstate);
16045 if (PyErr_Occurred()) SWIG_fail;
16046 }
16047 resultobj = SWIG_From_int(static_cast< int >(result));
16048 return resultobj;
16049 fail:
16050 return NULL;
16051 }
16052
16053
16054 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16055 PyObject *resultobj = 0;
16056 wxJoystick *arg1 = (wxJoystick *) 0 ;
16057 int result;
16058 void *argp1 = 0 ;
16059 int res1 = 0 ;
16060 PyObject *swig_obj[1] ;
16061
16062 if (!args) SWIG_fail;
16063 swig_obj[0] = args;
16064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16065 if (!SWIG_IsOK(res1)) {
16066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16067 }
16068 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 result = (int)(arg1)->GetUMax();
16072 wxPyEndAllowThreads(__tstate);
16073 if (PyErr_Occurred()) SWIG_fail;
16074 }
16075 resultobj = SWIG_From_int(static_cast< int >(result));
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16083 PyObject *resultobj = 0;
16084 wxJoystick *arg1 = (wxJoystick *) 0 ;
16085 int result;
16086 void *argp1 = 0 ;
16087 int res1 = 0 ;
16088 PyObject *swig_obj[1] ;
16089
16090 if (!args) SWIG_fail;
16091 swig_obj[0] = args;
16092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16093 if (!SWIG_IsOK(res1)) {
16094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16095 }
16096 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16097 {
16098 PyThreadState* __tstate = wxPyBeginAllowThreads();
16099 result = (int)(arg1)->GetVMin();
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 resultobj = SWIG_From_int(static_cast< int >(result));
16104 return resultobj;
16105 fail:
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16111 PyObject *resultobj = 0;
16112 wxJoystick *arg1 = (wxJoystick *) 0 ;
16113 int result;
16114 void *argp1 = 0 ;
16115 int res1 = 0 ;
16116 PyObject *swig_obj[1] ;
16117
16118 if (!args) SWIG_fail;
16119 swig_obj[0] = args;
16120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16121 if (!SWIG_IsOK(res1)) {
16122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16123 }
16124 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (int)(arg1)->GetVMax();
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 resultobj = SWIG_From_int(static_cast< int >(result));
16132 return resultobj;
16133 fail:
16134 return NULL;
16135 }
16136
16137
16138 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16139 PyObject *resultobj = 0;
16140 wxJoystick *arg1 = (wxJoystick *) 0 ;
16141 bool result;
16142 void *argp1 = 0 ;
16143 int res1 = 0 ;
16144 PyObject *swig_obj[1] ;
16145
16146 if (!args) SWIG_fail;
16147 swig_obj[0] = args;
16148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16149 if (!SWIG_IsOK(res1)) {
16150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16151 }
16152 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (bool)(arg1)->HasRudder();
16156 wxPyEndAllowThreads(__tstate);
16157 if (PyErr_Occurred()) SWIG_fail;
16158 }
16159 {
16160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16161 }
16162 return resultobj;
16163 fail:
16164 return NULL;
16165 }
16166
16167
16168 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16169 PyObject *resultobj = 0;
16170 wxJoystick *arg1 = (wxJoystick *) 0 ;
16171 bool result;
16172 void *argp1 = 0 ;
16173 int res1 = 0 ;
16174 PyObject *swig_obj[1] ;
16175
16176 if (!args) SWIG_fail;
16177 swig_obj[0] = args;
16178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16179 if (!SWIG_IsOK(res1)) {
16180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16181 }
16182 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16183 {
16184 PyThreadState* __tstate = wxPyBeginAllowThreads();
16185 result = (bool)(arg1)->HasZ();
16186 wxPyEndAllowThreads(__tstate);
16187 if (PyErr_Occurred()) SWIG_fail;
16188 }
16189 {
16190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16191 }
16192 return resultobj;
16193 fail:
16194 return NULL;
16195 }
16196
16197
16198 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16199 PyObject *resultobj = 0;
16200 wxJoystick *arg1 = (wxJoystick *) 0 ;
16201 bool result;
16202 void *argp1 = 0 ;
16203 int res1 = 0 ;
16204 PyObject *swig_obj[1] ;
16205
16206 if (!args) SWIG_fail;
16207 swig_obj[0] = args;
16208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16209 if (!SWIG_IsOK(res1)) {
16210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16211 }
16212 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16213 {
16214 PyThreadState* __tstate = wxPyBeginAllowThreads();
16215 result = (bool)(arg1)->HasU();
16216 wxPyEndAllowThreads(__tstate);
16217 if (PyErr_Occurred()) SWIG_fail;
16218 }
16219 {
16220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16221 }
16222 return resultobj;
16223 fail:
16224 return NULL;
16225 }
16226
16227
16228 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16229 PyObject *resultobj = 0;
16230 wxJoystick *arg1 = (wxJoystick *) 0 ;
16231 bool result;
16232 void *argp1 = 0 ;
16233 int res1 = 0 ;
16234 PyObject *swig_obj[1] ;
16235
16236 if (!args) SWIG_fail;
16237 swig_obj[0] = args;
16238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16241 }
16242 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16243 {
16244 PyThreadState* __tstate = wxPyBeginAllowThreads();
16245 result = (bool)(arg1)->HasV();
16246 wxPyEndAllowThreads(__tstate);
16247 if (PyErr_Occurred()) SWIG_fail;
16248 }
16249 {
16250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16251 }
16252 return resultobj;
16253 fail:
16254 return NULL;
16255 }
16256
16257
16258 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16259 PyObject *resultobj = 0;
16260 wxJoystick *arg1 = (wxJoystick *) 0 ;
16261 bool result;
16262 void *argp1 = 0 ;
16263 int res1 = 0 ;
16264 PyObject *swig_obj[1] ;
16265
16266 if (!args) SWIG_fail;
16267 swig_obj[0] = args;
16268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16269 if (!SWIG_IsOK(res1)) {
16270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16271 }
16272 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (bool)(arg1)->HasPOV();
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 {
16280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16281 }
16282 return resultobj;
16283 fail:
16284 return NULL;
16285 }
16286
16287
16288 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16289 PyObject *resultobj = 0;
16290 wxJoystick *arg1 = (wxJoystick *) 0 ;
16291 bool result;
16292 void *argp1 = 0 ;
16293 int res1 = 0 ;
16294 PyObject *swig_obj[1] ;
16295
16296 if (!args) SWIG_fail;
16297 swig_obj[0] = args;
16298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16299 if (!SWIG_IsOK(res1)) {
16300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16301 }
16302 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 result = (bool)(arg1)->HasPOV4Dir();
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 {
16310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16311 }
16312 return resultobj;
16313 fail:
16314 return NULL;
16315 }
16316
16317
16318 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16319 PyObject *resultobj = 0;
16320 wxJoystick *arg1 = (wxJoystick *) 0 ;
16321 bool result;
16322 void *argp1 = 0 ;
16323 int res1 = 0 ;
16324 PyObject *swig_obj[1] ;
16325
16326 if (!args) SWIG_fail;
16327 swig_obj[0] = args;
16328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16329 if (!SWIG_IsOK(res1)) {
16330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16331 }
16332 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16333 {
16334 PyThreadState* __tstate = wxPyBeginAllowThreads();
16335 result = (bool)(arg1)->HasPOVCTS();
16336 wxPyEndAllowThreads(__tstate);
16337 if (PyErr_Occurred()) SWIG_fail;
16338 }
16339 {
16340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16341 }
16342 return resultobj;
16343 fail:
16344 return NULL;
16345 }
16346
16347
16348 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16349 PyObject *resultobj = 0;
16350 wxJoystick *arg1 = (wxJoystick *) 0 ;
16351 wxWindow *arg2 = (wxWindow *) 0 ;
16352 int arg3 = (int) 0 ;
16353 bool result;
16354 void *argp1 = 0 ;
16355 int res1 = 0 ;
16356 void *argp2 = 0 ;
16357 int res2 = 0 ;
16358 int val3 ;
16359 int ecode3 = 0 ;
16360 PyObject * obj0 = 0 ;
16361 PyObject * obj1 = 0 ;
16362 PyObject * obj2 = 0 ;
16363 char * kwnames[] = {
16364 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16365 };
16366
16367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16369 if (!SWIG_IsOK(res1)) {
16370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16371 }
16372 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16374 if (!SWIG_IsOK(res2)) {
16375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16376 }
16377 arg2 = reinterpret_cast< wxWindow * >(argp2);
16378 if (obj2) {
16379 ecode3 = SWIG_AsVal_int(obj2, &val3);
16380 if (!SWIG_IsOK(ecode3)) {
16381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16382 }
16383 arg3 = static_cast< int >(val3);
16384 }
16385 {
16386 PyThreadState* __tstate = wxPyBeginAllowThreads();
16387 result = (bool)(arg1)->SetCapture(arg2,arg3);
16388 wxPyEndAllowThreads(__tstate);
16389 if (PyErr_Occurred()) SWIG_fail;
16390 }
16391 {
16392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16393 }
16394 return resultobj;
16395 fail:
16396 return NULL;
16397 }
16398
16399
16400 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16401 PyObject *resultobj = 0;
16402 wxJoystick *arg1 = (wxJoystick *) 0 ;
16403 bool result;
16404 void *argp1 = 0 ;
16405 int res1 = 0 ;
16406 PyObject *swig_obj[1] ;
16407
16408 if (!args) SWIG_fail;
16409 swig_obj[0] = args;
16410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16411 if (!SWIG_IsOK(res1)) {
16412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16413 }
16414 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 result = (bool)(arg1)->ReleaseCapture();
16418 wxPyEndAllowThreads(__tstate);
16419 if (PyErr_Occurred()) SWIG_fail;
16420 }
16421 {
16422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16423 }
16424 return resultobj;
16425 fail:
16426 return NULL;
16427 }
16428
16429
16430 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16431 PyObject *obj;
16432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16433 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16434 return SWIG_Py_Void();
16435 }
16436
16437 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16438 return SWIG_Python_InitShadowInstance(args);
16439 }
16440
16441 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16442 PyObject *resultobj = 0;
16443 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16444 int arg2 = (int) 0 ;
16445 int arg3 = (int) wxJOYSTICK1 ;
16446 int arg4 = (int) 0 ;
16447 wxJoystickEvent *result = 0 ;
16448 int val1 ;
16449 int ecode1 = 0 ;
16450 int val2 ;
16451 int ecode2 = 0 ;
16452 int val3 ;
16453 int ecode3 = 0 ;
16454 int val4 ;
16455 int ecode4 = 0 ;
16456 PyObject * obj0 = 0 ;
16457 PyObject * obj1 = 0 ;
16458 PyObject * obj2 = 0 ;
16459 PyObject * obj3 = 0 ;
16460 char * kwnames[] = {
16461 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16462 };
16463
16464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16465 if (obj0) {
16466 ecode1 = SWIG_AsVal_int(obj0, &val1);
16467 if (!SWIG_IsOK(ecode1)) {
16468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16469 }
16470 arg1 = static_cast< wxEventType >(val1);
16471 }
16472 if (obj1) {
16473 ecode2 = SWIG_AsVal_int(obj1, &val2);
16474 if (!SWIG_IsOK(ecode2)) {
16475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16476 }
16477 arg2 = static_cast< int >(val2);
16478 }
16479 if (obj2) {
16480 ecode3 = SWIG_AsVal_int(obj2, &val3);
16481 if (!SWIG_IsOK(ecode3)) {
16482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16483 }
16484 arg3 = static_cast< int >(val3);
16485 }
16486 if (obj3) {
16487 ecode4 = SWIG_AsVal_int(obj3, &val4);
16488 if (!SWIG_IsOK(ecode4)) {
16489 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16490 }
16491 arg4 = static_cast< int >(val4);
16492 }
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16507 PyObject *resultobj = 0;
16508 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16509 wxPoint result;
16510 void *argp1 = 0 ;
16511 int res1 = 0 ;
16512 PyObject *swig_obj[1] ;
16513
16514 if (!args) SWIG_fail;
16515 swig_obj[0] = args;
16516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16517 if (!SWIG_IsOK(res1)) {
16518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16519 }
16520 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16524 wxPyEndAllowThreads(__tstate);
16525 if (PyErr_Occurred()) SWIG_fail;
16526 }
16527 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16535 PyObject *resultobj = 0;
16536 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16537 int result;
16538 void *argp1 = 0 ;
16539 int res1 = 0 ;
16540 PyObject *swig_obj[1] ;
16541
16542 if (!args) SWIG_fail;
16543 swig_obj[0] = args;
16544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16545 if (!SWIG_IsOK(res1)) {
16546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16547 }
16548 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16549 {
16550 PyThreadState* __tstate = wxPyBeginAllowThreads();
16551 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16552 wxPyEndAllowThreads(__tstate);
16553 if (PyErr_Occurred()) SWIG_fail;
16554 }
16555 resultobj = SWIG_From_int(static_cast< int >(result));
16556 return resultobj;
16557 fail:
16558 return NULL;
16559 }
16560
16561
16562 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16563 PyObject *resultobj = 0;
16564 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16565 int result;
16566 void *argp1 = 0 ;
16567 int res1 = 0 ;
16568 PyObject *swig_obj[1] ;
16569
16570 if (!args) SWIG_fail;
16571 swig_obj[0] = args;
16572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16573 if (!SWIG_IsOK(res1)) {
16574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16575 }
16576 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16580 wxPyEndAllowThreads(__tstate);
16581 if (PyErr_Occurred()) SWIG_fail;
16582 }
16583 resultobj = SWIG_From_int(static_cast< int >(result));
16584 return resultobj;
16585 fail:
16586 return NULL;
16587 }
16588
16589
16590 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16591 PyObject *resultobj = 0;
16592 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16593 int result;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 PyObject *swig_obj[1] ;
16597
16598 if (!args) SWIG_fail;
16599 swig_obj[0] = args;
16600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16601 if (!SWIG_IsOK(res1)) {
16602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16603 }
16604 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 resultobj = SWIG_From_int(static_cast< int >(result));
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16619 PyObject *resultobj = 0;
16620 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16621 int result;
16622 void *argp1 = 0 ;
16623 int res1 = 0 ;
16624 PyObject *swig_obj[1] ;
16625
16626 if (!args) SWIG_fail;
16627 swig_obj[0] = args;
16628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16629 if (!SWIG_IsOK(res1)) {
16630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16631 }
16632 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16633 {
16634 PyThreadState* __tstate = wxPyBeginAllowThreads();
16635 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16636 wxPyEndAllowThreads(__tstate);
16637 if (PyErr_Occurred()) SWIG_fail;
16638 }
16639 resultobj = SWIG_From_int(static_cast< int >(result));
16640 return resultobj;
16641 fail:
16642 return NULL;
16643 }
16644
16645
16646 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16647 PyObject *resultobj = 0;
16648 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16649 int arg2 ;
16650 void *argp1 = 0 ;
16651 int res1 = 0 ;
16652 int val2 ;
16653 int ecode2 = 0 ;
16654 PyObject * obj0 = 0 ;
16655 PyObject * obj1 = 0 ;
16656 char * kwnames[] = {
16657 (char *) "self",(char *) "stick", NULL
16658 };
16659
16660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16662 if (!SWIG_IsOK(res1)) {
16663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16664 }
16665 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16666 ecode2 = SWIG_AsVal_int(obj1, &val2);
16667 if (!SWIG_IsOK(ecode2)) {
16668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16669 }
16670 arg2 = static_cast< int >(val2);
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 (arg1)->SetJoystick(arg2);
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 resultobj = SWIG_Py_Void();
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16685 PyObject *resultobj = 0;
16686 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16687 int arg2 ;
16688 void *argp1 = 0 ;
16689 int res1 = 0 ;
16690 int val2 ;
16691 int ecode2 = 0 ;
16692 PyObject * obj0 = 0 ;
16693 PyObject * obj1 = 0 ;
16694 char * kwnames[] = {
16695 (char *) "self",(char *) "state", NULL
16696 };
16697
16698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16700 if (!SWIG_IsOK(res1)) {
16701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16702 }
16703 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16704 ecode2 = SWIG_AsVal_int(obj1, &val2);
16705 if (!SWIG_IsOK(ecode2)) {
16706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16707 }
16708 arg2 = static_cast< int >(val2);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 (arg1)->SetButtonState(arg2);
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_Py_Void();
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj = 0;
16724 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16725 int arg2 ;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 int val2 ;
16729 int ecode2 = 0 ;
16730 PyObject * obj0 = 0 ;
16731 PyObject * obj1 = 0 ;
16732 char * kwnames[] = {
16733 (char *) "self",(char *) "change", NULL
16734 };
16735
16736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16738 if (!SWIG_IsOK(res1)) {
16739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16740 }
16741 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16742 ecode2 = SWIG_AsVal_int(obj1, &val2);
16743 if (!SWIG_IsOK(ecode2)) {
16744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16745 }
16746 arg2 = static_cast< int >(val2);
16747 {
16748 PyThreadState* __tstate = wxPyBeginAllowThreads();
16749 (arg1)->SetButtonChange(arg2);
16750 wxPyEndAllowThreads(__tstate);
16751 if (PyErr_Occurred()) SWIG_fail;
16752 }
16753 resultobj = SWIG_Py_Void();
16754 return resultobj;
16755 fail:
16756 return NULL;
16757 }
16758
16759
16760 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16761 PyObject *resultobj = 0;
16762 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16763 wxPoint *arg2 = 0 ;
16764 void *argp1 = 0 ;
16765 int res1 = 0 ;
16766 wxPoint temp2 ;
16767 PyObject * obj0 = 0 ;
16768 PyObject * obj1 = 0 ;
16769 char * kwnames[] = {
16770 (char *) "self",(char *) "pos", NULL
16771 };
16772
16773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16775 if (!SWIG_IsOK(res1)) {
16776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16777 }
16778 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16779 {
16780 arg2 = &temp2;
16781 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16782 }
16783 {
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 (arg1)->SetPosition((wxPoint const &)*arg2);
16786 wxPyEndAllowThreads(__tstate);
16787 if (PyErr_Occurred()) SWIG_fail;
16788 }
16789 resultobj = SWIG_Py_Void();
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj = 0;
16798 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16799 int arg2 ;
16800 void *argp1 = 0 ;
16801 int res1 = 0 ;
16802 int val2 ;
16803 int ecode2 = 0 ;
16804 PyObject * obj0 = 0 ;
16805 PyObject * obj1 = 0 ;
16806 char * kwnames[] = {
16807 (char *) "self",(char *) "zPos", NULL
16808 };
16809
16810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16812 if (!SWIG_IsOK(res1)) {
16813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16814 }
16815 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16816 ecode2 = SWIG_AsVal_int(obj1, &val2);
16817 if (!SWIG_IsOK(ecode2)) {
16818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16819 }
16820 arg2 = static_cast< int >(val2);
16821 {
16822 PyThreadState* __tstate = wxPyBeginAllowThreads();
16823 (arg1)->SetZPosition(arg2);
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 resultobj = SWIG_Py_Void();
16828 return resultobj;
16829 fail:
16830 return NULL;
16831 }
16832
16833
16834 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16835 PyObject *resultobj = 0;
16836 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16837 bool result;
16838 void *argp1 = 0 ;
16839 int res1 = 0 ;
16840 PyObject *swig_obj[1] ;
16841
16842 if (!args) SWIG_fail;
16843 swig_obj[0] = args;
16844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16845 if (!SWIG_IsOK(res1)) {
16846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16847 }
16848 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16849 {
16850 PyThreadState* __tstate = wxPyBeginAllowThreads();
16851 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 {
16856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16857 }
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16865 PyObject *resultobj = 0;
16866 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16867 bool result;
16868 void *argp1 = 0 ;
16869 int res1 = 0 ;
16870 PyObject *swig_obj[1] ;
16871
16872 if (!args) SWIG_fail;
16873 swig_obj[0] = args;
16874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16875 if (!SWIG_IsOK(res1)) {
16876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16877 }
16878 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 {
16886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16887 }
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16895 PyObject *resultobj = 0;
16896 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16897 bool result;
16898 void *argp1 = 0 ;
16899 int res1 = 0 ;
16900 PyObject *swig_obj[1] ;
16901
16902 if (!args) SWIG_fail;
16903 swig_obj[0] = args;
16904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16905 if (!SWIG_IsOK(res1)) {
16906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16907 }
16908 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16909 {
16910 PyThreadState* __tstate = wxPyBeginAllowThreads();
16911 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16912 wxPyEndAllowThreads(__tstate);
16913 if (PyErr_Occurred()) SWIG_fail;
16914 }
16915 {
16916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16917 }
16918 return resultobj;
16919 fail:
16920 return NULL;
16921 }
16922
16923
16924 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16925 PyObject *resultobj = 0;
16926 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16927 int arg2 = (int) wxJOY_BUTTON_ANY ;
16928 bool result;
16929 void *argp1 = 0 ;
16930 int res1 = 0 ;
16931 int val2 ;
16932 int ecode2 = 0 ;
16933 PyObject * obj0 = 0 ;
16934 PyObject * obj1 = 0 ;
16935 char * kwnames[] = {
16936 (char *) "self",(char *) "but", NULL
16937 };
16938
16939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16941 if (!SWIG_IsOK(res1)) {
16942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16943 }
16944 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16945 if (obj1) {
16946 ecode2 = SWIG_AsVal_int(obj1, &val2);
16947 if (!SWIG_IsOK(ecode2)) {
16948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16949 }
16950 arg2 = static_cast< int >(val2);
16951 }
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 {
16959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16960 }
16961 return resultobj;
16962 fail:
16963 return NULL;
16964 }
16965
16966
16967 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16968 PyObject *resultobj = 0;
16969 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16970 int arg2 = (int) wxJOY_BUTTON_ANY ;
16971 bool result;
16972 void *argp1 = 0 ;
16973 int res1 = 0 ;
16974 int val2 ;
16975 int ecode2 = 0 ;
16976 PyObject * obj0 = 0 ;
16977 PyObject * obj1 = 0 ;
16978 char * kwnames[] = {
16979 (char *) "self",(char *) "but", NULL
16980 };
16981
16982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16984 if (!SWIG_IsOK(res1)) {
16985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16986 }
16987 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16988 if (obj1) {
16989 ecode2 = SWIG_AsVal_int(obj1, &val2);
16990 if (!SWIG_IsOK(ecode2)) {
16991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16992 }
16993 arg2 = static_cast< int >(val2);
16994 }
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16998 wxPyEndAllowThreads(__tstate);
16999 if (PyErr_Occurred()) SWIG_fail;
17000 }
17001 {
17002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17003 }
17004 return resultobj;
17005 fail:
17006 return NULL;
17007 }
17008
17009
17010 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17011 PyObject *resultobj = 0;
17012 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17013 int arg2 = (int) wxJOY_BUTTON_ANY ;
17014 bool result;
17015 void *argp1 = 0 ;
17016 int res1 = 0 ;
17017 int val2 ;
17018 int ecode2 = 0 ;
17019 PyObject * obj0 = 0 ;
17020 PyObject * obj1 = 0 ;
17021 char * kwnames[] = {
17022 (char *) "self",(char *) "but", NULL
17023 };
17024
17025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17027 if (!SWIG_IsOK(res1)) {
17028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17029 }
17030 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17031 if (obj1) {
17032 ecode2 = SWIG_AsVal_int(obj1, &val2);
17033 if (!SWIG_IsOK(ecode2)) {
17034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17035 }
17036 arg2 = static_cast< int >(val2);
17037 }
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 {
17045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17046 }
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17054 PyObject *obj;
17055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17056 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17057 return SWIG_Py_Void();
17058 }
17059
17060 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17061 return SWIG_Python_InitShadowInstance(args);
17062 }
17063
17064 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17065 PyObject *resultobj = 0;
17066 wxString const &arg1_defvalue = wxPyEmptyString ;
17067 wxString *arg1 = (wxString *) &arg1_defvalue ;
17068 wxSound *result = 0 ;
17069 bool temp1 = false ;
17070 PyObject * obj0 = 0 ;
17071 char * kwnames[] = {
17072 (char *) "fileName", NULL
17073 };
17074
17075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17076 if (obj0) {
17077 {
17078 arg1 = wxString_in_helper(obj0);
17079 if (arg1 == NULL) SWIG_fail;
17080 temp1 = true;
17081 }
17082 }
17083 {
17084 if (!wxPyCheckForApp()) SWIG_fail;
17085 PyThreadState* __tstate = wxPyBeginAllowThreads();
17086 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17087 wxPyEndAllowThreads(__tstate);
17088 if (PyErr_Occurred()) SWIG_fail;
17089 }
17090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17091 {
17092 if (temp1)
17093 delete arg1;
17094 }
17095 return resultobj;
17096 fail:
17097 {
17098 if (temp1)
17099 delete arg1;
17100 }
17101 return NULL;
17102 }
17103
17104
17105 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj = 0;
17107 PyObject *arg1 = (PyObject *) 0 ;
17108 wxSound *result = 0 ;
17109 PyObject * obj0 = 0 ;
17110 char * kwnames[] = {
17111 (char *) "data", NULL
17112 };
17113
17114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17115 arg1 = obj0;
17116 {
17117 if (!wxPyCheckForApp()) SWIG_fail;
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 result = (wxSound *)new_wxSound(arg1);
17120 wxPyEndAllowThreads(__tstate);
17121 if (PyErr_Occurred()) SWIG_fail;
17122 }
17123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17124 return resultobj;
17125 fail:
17126 return NULL;
17127 }
17128
17129
17130 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17131 PyObject *resultobj = 0;
17132 wxSound *arg1 = (wxSound *) 0 ;
17133 void *argp1 = 0 ;
17134 int res1 = 0 ;
17135 PyObject *swig_obj[1] ;
17136
17137 if (!args) SWIG_fail;
17138 swig_obj[0] = args;
17139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17140 if (!SWIG_IsOK(res1)) {
17141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17142 }
17143 arg1 = reinterpret_cast< wxSound * >(argp1);
17144 {
17145 PyThreadState* __tstate = wxPyBeginAllowThreads();
17146 delete arg1;
17147
17148 wxPyEndAllowThreads(__tstate);
17149 if (PyErr_Occurred()) SWIG_fail;
17150 }
17151 resultobj = SWIG_Py_Void();
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17159 PyObject *resultobj = 0;
17160 wxSound *arg1 = (wxSound *) 0 ;
17161 wxString *arg2 = 0 ;
17162 bool result;
17163 void *argp1 = 0 ;
17164 int res1 = 0 ;
17165 bool temp2 = false ;
17166 PyObject * obj0 = 0 ;
17167 PyObject * obj1 = 0 ;
17168 char * kwnames[] = {
17169 (char *) "self",(char *) "fileName", NULL
17170 };
17171
17172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17174 if (!SWIG_IsOK(res1)) {
17175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17176 }
17177 arg1 = reinterpret_cast< wxSound * >(argp1);
17178 {
17179 arg2 = wxString_in_helper(obj1);
17180 if (arg2 == NULL) SWIG_fail;
17181 temp2 = true;
17182 }
17183 {
17184 PyThreadState* __tstate = wxPyBeginAllowThreads();
17185 result = (bool)(arg1)->Create((wxString const &)*arg2);
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 {
17190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17191 }
17192 {
17193 if (temp2)
17194 delete arg2;
17195 }
17196 return resultobj;
17197 fail:
17198 {
17199 if (temp2)
17200 delete arg2;
17201 }
17202 return NULL;
17203 }
17204
17205
17206 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17207 PyObject *resultobj = 0;
17208 wxSound *arg1 = (wxSound *) 0 ;
17209 PyObject *arg2 = (PyObject *) 0 ;
17210 bool result;
17211 void *argp1 = 0 ;
17212 int res1 = 0 ;
17213 PyObject * obj0 = 0 ;
17214 PyObject * obj1 = 0 ;
17215 char * kwnames[] = {
17216 (char *) "self",(char *) "data", NULL
17217 };
17218
17219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17221 if (!SWIG_IsOK(res1)) {
17222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17223 }
17224 arg1 = reinterpret_cast< wxSound * >(argp1);
17225 arg2 = obj1;
17226 {
17227 PyThreadState* __tstate = wxPyBeginAllowThreads();
17228 result = (bool)wxSound_CreateFromData(arg1,arg2);
17229 wxPyEndAllowThreads(__tstate);
17230 if (PyErr_Occurred()) SWIG_fail;
17231 }
17232 {
17233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17234 }
17235 return resultobj;
17236 fail:
17237 return NULL;
17238 }
17239
17240
17241 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17242 PyObject *resultobj = 0;
17243 wxSound *arg1 = (wxSound *) 0 ;
17244 bool result;
17245 void *argp1 = 0 ;
17246 int res1 = 0 ;
17247 PyObject *swig_obj[1] ;
17248
17249 if (!args) SWIG_fail;
17250 swig_obj[0] = args;
17251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17252 if (!SWIG_IsOK(res1)) {
17253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17254 }
17255 arg1 = reinterpret_cast< wxSound * >(argp1);
17256 {
17257 PyThreadState* __tstate = wxPyBeginAllowThreads();
17258 result = (bool)(arg1)->IsOk();
17259 wxPyEndAllowThreads(__tstate);
17260 if (PyErr_Occurred()) SWIG_fail;
17261 }
17262 {
17263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17264 }
17265 return resultobj;
17266 fail:
17267 return NULL;
17268 }
17269
17270
17271 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17272 PyObject *resultobj = 0;
17273 wxSound *arg1 = (wxSound *) 0 ;
17274 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17275 bool result;
17276 void *argp1 = 0 ;
17277 int res1 = 0 ;
17278 unsigned int val2 ;
17279 int ecode2 = 0 ;
17280 PyObject * obj0 = 0 ;
17281 PyObject * obj1 = 0 ;
17282 char * kwnames[] = {
17283 (char *) "self",(char *) "flags", NULL
17284 };
17285
17286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17288 if (!SWIG_IsOK(res1)) {
17289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17290 }
17291 arg1 = reinterpret_cast< wxSound * >(argp1);
17292 if (obj1) {
17293 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17294 if (!SWIG_IsOK(ecode2)) {
17295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17296 }
17297 arg2 = static_cast< unsigned int >(val2);
17298 }
17299 {
17300 if (!wxPyCheckForApp()) SWIG_fail;
17301 PyThreadState* __tstate = wxPyBeginAllowThreads();
17302 result = (bool)((wxSound const *)arg1)->Play(arg2);
17303 wxPyEndAllowThreads(__tstate);
17304 if (PyErr_Occurred()) SWIG_fail;
17305 }
17306 {
17307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17308 }
17309 return resultobj;
17310 fail:
17311 return NULL;
17312 }
17313
17314
17315 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17316 PyObject *resultobj = 0;
17317 wxString *arg1 = 0 ;
17318 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17319 bool result;
17320 bool temp1 = false ;
17321 unsigned int val2 ;
17322 int ecode2 = 0 ;
17323 PyObject * obj0 = 0 ;
17324 PyObject * obj1 = 0 ;
17325 char * kwnames[] = {
17326 (char *) "filename",(char *) "flags", NULL
17327 };
17328
17329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17330 {
17331 arg1 = wxString_in_helper(obj0);
17332 if (arg1 == NULL) SWIG_fail;
17333 temp1 = true;
17334 }
17335 if (obj1) {
17336 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17337 if (!SWIG_IsOK(ecode2)) {
17338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17339 }
17340 arg2 = static_cast< unsigned int >(val2);
17341 }
17342 {
17343 if (!wxPyCheckForApp()) SWIG_fail;
17344 PyThreadState* __tstate = wxPyBeginAllowThreads();
17345 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17346 wxPyEndAllowThreads(__tstate);
17347 if (PyErr_Occurred()) SWIG_fail;
17348 }
17349 {
17350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17351 }
17352 {
17353 if (temp1)
17354 delete arg1;
17355 }
17356 return resultobj;
17357 fail:
17358 {
17359 if (temp1)
17360 delete arg1;
17361 }
17362 return NULL;
17363 }
17364
17365
17366 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17367 PyObject *resultobj = 0;
17368
17369 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17370 {
17371 if (!wxPyCheckForApp()) SWIG_fail;
17372 PyThreadState* __tstate = wxPyBeginAllowThreads();
17373 wxSound::Stop();
17374 wxPyEndAllowThreads(__tstate);
17375 if (PyErr_Occurred()) SWIG_fail;
17376 }
17377 resultobj = SWIG_Py_Void();
17378 return resultobj;
17379 fail:
17380 return NULL;
17381 }
17382
17383
17384 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17385 PyObject *obj;
17386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17387 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17388 return SWIG_Py_Void();
17389 }
17390
17391 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17392 return SWIG_Python_InitShadowInstance(args);
17393 }
17394
17395 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17396 PyObject *resultobj = 0;
17397 wxString *arg1 = 0 ;
17398 wxString *arg2 = 0 ;
17399 wxString *arg3 = 0 ;
17400 wxString *arg4 = 0 ;
17401 wxFileTypeInfo *result = 0 ;
17402 bool temp1 = false ;
17403 bool temp2 = false ;
17404 bool temp3 = false ;
17405 bool temp4 = false ;
17406 PyObject * obj0 = 0 ;
17407 PyObject * obj1 = 0 ;
17408 PyObject * obj2 = 0 ;
17409 PyObject * obj3 = 0 ;
17410 char * kwnames[] = {
17411 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17412 };
17413
17414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17415 {
17416 arg1 = wxString_in_helper(obj0);
17417 if (arg1 == NULL) SWIG_fail;
17418 temp1 = true;
17419 }
17420 {
17421 arg2 = wxString_in_helper(obj1);
17422 if (arg2 == NULL) SWIG_fail;
17423 temp2 = true;
17424 }
17425 {
17426 arg3 = wxString_in_helper(obj2);
17427 if (arg3 == NULL) SWIG_fail;
17428 temp3 = true;
17429 }
17430 {
17431 arg4 = wxString_in_helper(obj3);
17432 if (arg4 == NULL) SWIG_fail;
17433 temp4 = true;
17434 }
17435 {
17436 PyThreadState* __tstate = wxPyBeginAllowThreads();
17437 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17438 wxPyEndAllowThreads(__tstate);
17439 if (PyErr_Occurred()) SWIG_fail;
17440 }
17441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17442 {
17443 if (temp1)
17444 delete arg1;
17445 }
17446 {
17447 if (temp2)
17448 delete arg2;
17449 }
17450 {
17451 if (temp3)
17452 delete arg3;
17453 }
17454 {
17455 if (temp4)
17456 delete arg4;
17457 }
17458 return resultobj;
17459 fail:
17460 {
17461 if (temp1)
17462 delete arg1;
17463 }
17464 {
17465 if (temp2)
17466 delete arg2;
17467 }
17468 {
17469 if (temp3)
17470 delete arg3;
17471 }
17472 {
17473 if (temp4)
17474 delete arg4;
17475 }
17476 return NULL;
17477 }
17478
17479
17480 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17481 PyObject *resultobj = 0;
17482 wxArrayString *arg1 = 0 ;
17483 wxFileTypeInfo *result = 0 ;
17484 bool temp1 = false ;
17485 PyObject * obj0 = 0 ;
17486 char * kwnames[] = {
17487 (char *) "sArray", NULL
17488 };
17489
17490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17491 {
17492 if (! PySequence_Check(obj0)) {
17493 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17494 SWIG_fail;
17495 }
17496 arg1 = new wxArrayString;
17497 temp1 = true;
17498 int i, len=PySequence_Length(obj0);
17499 for (i=0; i<len; i++) {
17500 PyObject* item = PySequence_GetItem(obj0, i);
17501 wxString* s = wxString_in_helper(item);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 arg1->Add(*s);
17504 delete s;
17505 Py_DECREF(item);
17506 }
17507 }
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17515 {
17516 if (temp1) delete arg1;
17517 }
17518 return resultobj;
17519 fail:
17520 {
17521 if (temp1) delete arg1;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17528 PyObject *resultobj = 0;
17529 wxFileTypeInfo *result = 0 ;
17530
17531 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17535 wxPyEndAllowThreads(__tstate);
17536 if (PyErr_Occurred()) SWIG_fail;
17537 }
17538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17539 return resultobj;
17540 fail:
17541 return NULL;
17542 }
17543
17544
17545 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17546 PyObject *resultobj = 0;
17547 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17548 bool result;
17549 void *argp1 = 0 ;
17550 int res1 = 0 ;
17551 PyObject *swig_obj[1] ;
17552
17553 if (!args) SWIG_fail;
17554 swig_obj[0] = args;
17555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17556 if (!SWIG_IsOK(res1)) {
17557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17558 }
17559 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17563 wxPyEndAllowThreads(__tstate);
17564 if (PyErr_Occurred()) SWIG_fail;
17565 }
17566 {
17567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17568 }
17569 return resultobj;
17570 fail:
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17576 PyObject *resultobj = 0;
17577 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17578 wxString *arg2 = 0 ;
17579 int arg3 = (int) 0 ;
17580 void *argp1 = 0 ;
17581 int res1 = 0 ;
17582 bool temp2 = false ;
17583 int val3 ;
17584 int ecode3 = 0 ;
17585 PyObject * obj0 = 0 ;
17586 PyObject * obj1 = 0 ;
17587 PyObject * obj2 = 0 ;
17588 char * kwnames[] = {
17589 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17590 };
17591
17592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17594 if (!SWIG_IsOK(res1)) {
17595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17596 }
17597 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17598 {
17599 arg2 = wxString_in_helper(obj1);
17600 if (arg2 == NULL) SWIG_fail;
17601 temp2 = true;
17602 }
17603 if (obj2) {
17604 ecode3 = SWIG_AsVal_int(obj2, &val3);
17605 if (!SWIG_IsOK(ecode3)) {
17606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17607 }
17608 arg3 = static_cast< int >(val3);
17609 }
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 resultobj = SWIG_Py_Void();
17617 {
17618 if (temp2)
17619 delete arg2;
17620 }
17621 return resultobj;
17622 fail:
17623 {
17624 if (temp2)
17625 delete arg2;
17626 }
17627 return NULL;
17628 }
17629
17630
17631 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17632 PyObject *resultobj = 0;
17633 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17634 wxString *arg2 = 0 ;
17635 void *argp1 = 0 ;
17636 int res1 = 0 ;
17637 bool temp2 = false ;
17638 PyObject * obj0 = 0 ;
17639 PyObject * obj1 = 0 ;
17640 char * kwnames[] = {
17641 (char *) "self",(char *) "shortDesc", NULL
17642 };
17643
17644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17646 if (!SWIG_IsOK(res1)) {
17647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17648 }
17649 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17650 {
17651 arg2 = wxString_in_helper(obj1);
17652 if (arg2 == NULL) SWIG_fail;
17653 temp2 = true;
17654 }
17655 {
17656 PyThreadState* __tstate = wxPyBeginAllowThreads();
17657 (arg1)->SetShortDesc((wxString const &)*arg2);
17658 wxPyEndAllowThreads(__tstate);
17659 if (PyErr_Occurred()) SWIG_fail;
17660 }
17661 resultobj = SWIG_Py_Void();
17662 {
17663 if (temp2)
17664 delete arg2;
17665 }
17666 return resultobj;
17667 fail:
17668 {
17669 if (temp2)
17670 delete arg2;
17671 }
17672 return NULL;
17673 }
17674
17675
17676 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17677 PyObject *resultobj = 0;
17678 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17679 wxString *result = 0 ;
17680 void *argp1 = 0 ;
17681 int res1 = 0 ;
17682 PyObject *swig_obj[1] ;
17683
17684 if (!args) SWIG_fail;
17685 swig_obj[0] = args;
17686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17687 if (!SWIG_IsOK(res1)) {
17688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17689 }
17690 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17691 {
17692 PyThreadState* __tstate = wxPyBeginAllowThreads();
17693 {
17694 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17695 result = (wxString *) &_result_ref;
17696 }
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 {
17701 #if wxUSE_UNICODE
17702 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17703 #else
17704 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17705 #endif
17706 }
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17714 PyObject *resultobj = 0;
17715 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17716 wxString *result = 0 ;
17717 void *argp1 = 0 ;
17718 int res1 = 0 ;
17719 PyObject *swig_obj[1] ;
17720
17721 if (!args) SWIG_fail;
17722 swig_obj[0] = args;
17723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17724 if (!SWIG_IsOK(res1)) {
17725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17726 }
17727 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17728 {
17729 PyThreadState* __tstate = wxPyBeginAllowThreads();
17730 {
17731 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17732 result = (wxString *) &_result_ref;
17733 }
17734 wxPyEndAllowThreads(__tstate);
17735 if (PyErr_Occurred()) SWIG_fail;
17736 }
17737 {
17738 #if wxUSE_UNICODE
17739 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17740 #else
17741 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17742 #endif
17743 }
17744 return resultobj;
17745 fail:
17746 return NULL;
17747 }
17748
17749
17750 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17751 PyObject *resultobj = 0;
17752 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17753 wxString *result = 0 ;
17754 void *argp1 = 0 ;
17755 int res1 = 0 ;
17756 PyObject *swig_obj[1] ;
17757
17758 if (!args) SWIG_fail;
17759 swig_obj[0] = args;
17760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17761 if (!SWIG_IsOK(res1)) {
17762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17763 }
17764 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17765 {
17766 PyThreadState* __tstate = wxPyBeginAllowThreads();
17767 {
17768 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17769 result = (wxString *) &_result_ref;
17770 }
17771 wxPyEndAllowThreads(__tstate);
17772 if (PyErr_Occurred()) SWIG_fail;
17773 }
17774 {
17775 #if wxUSE_UNICODE
17776 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17777 #else
17778 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17779 #endif
17780 }
17781 return resultobj;
17782 fail:
17783 return NULL;
17784 }
17785
17786
17787 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17788 PyObject *resultobj = 0;
17789 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17790 wxString *result = 0 ;
17791 void *argp1 = 0 ;
17792 int res1 = 0 ;
17793 PyObject *swig_obj[1] ;
17794
17795 if (!args) SWIG_fail;
17796 swig_obj[0] = args;
17797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17798 if (!SWIG_IsOK(res1)) {
17799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17800 }
17801 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17802 {
17803 PyThreadState* __tstate = wxPyBeginAllowThreads();
17804 {
17805 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17806 result = (wxString *) &_result_ref;
17807 }
17808 wxPyEndAllowThreads(__tstate);
17809 if (PyErr_Occurred()) SWIG_fail;
17810 }
17811 {
17812 #if wxUSE_UNICODE
17813 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17814 #else
17815 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17816 #endif
17817 }
17818 return resultobj;
17819 fail:
17820 return NULL;
17821 }
17822
17823
17824 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17825 PyObject *resultobj = 0;
17826 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17827 wxString *result = 0 ;
17828 void *argp1 = 0 ;
17829 int res1 = 0 ;
17830 PyObject *swig_obj[1] ;
17831
17832 if (!args) SWIG_fail;
17833 swig_obj[0] = args;
17834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17835 if (!SWIG_IsOK(res1)) {
17836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17837 }
17838 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17839 {
17840 PyThreadState* __tstate = wxPyBeginAllowThreads();
17841 {
17842 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17843 result = (wxString *) &_result_ref;
17844 }
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 {
17849 #if wxUSE_UNICODE
17850 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17851 #else
17852 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17853 #endif
17854 }
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17862 PyObject *resultobj = 0;
17863 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17864 wxArrayString *result = 0 ;
17865 void *argp1 = 0 ;
17866 int res1 = 0 ;
17867 PyObject *swig_obj[1] ;
17868
17869 if (!args) SWIG_fail;
17870 swig_obj[0] = args;
17871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17872 if (!SWIG_IsOK(res1)) {
17873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17874 }
17875 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 {
17879 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17880 result = (wxArrayString *) &_result_ref;
17881 }
17882 wxPyEndAllowThreads(__tstate);
17883 if (PyErr_Occurred()) SWIG_fail;
17884 }
17885 {
17886 resultobj = wxArrayString2PyList_helper(*result);
17887 }
17888 return resultobj;
17889 fail:
17890 return NULL;
17891 }
17892
17893
17894 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17895 PyObject *resultobj = 0;
17896 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17897 size_t result;
17898 void *argp1 = 0 ;
17899 int res1 = 0 ;
17900 PyObject *swig_obj[1] ;
17901
17902 if (!args) SWIG_fail;
17903 swig_obj[0] = args;
17904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17905 if (!SWIG_IsOK(res1)) {
17906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17907 }
17908 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17909 {
17910 PyThreadState* __tstate = wxPyBeginAllowThreads();
17911 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17912 wxPyEndAllowThreads(__tstate);
17913 if (PyErr_Occurred()) SWIG_fail;
17914 }
17915 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17916 return resultobj;
17917 fail:
17918 return NULL;
17919 }
17920
17921
17922 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17923 PyObject *resultobj = 0;
17924 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17925 wxString *result = 0 ;
17926 void *argp1 = 0 ;
17927 int res1 = 0 ;
17928 PyObject *swig_obj[1] ;
17929
17930 if (!args) SWIG_fail;
17931 swig_obj[0] = args;
17932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17933 if (!SWIG_IsOK(res1)) {
17934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17935 }
17936 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17937 {
17938 PyThreadState* __tstate = wxPyBeginAllowThreads();
17939 {
17940 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17941 result = (wxString *) &_result_ref;
17942 }
17943 wxPyEndAllowThreads(__tstate);
17944 if (PyErr_Occurred()) SWIG_fail;
17945 }
17946 {
17947 #if wxUSE_UNICODE
17948 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17949 #else
17950 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17951 #endif
17952 }
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17960 PyObject *resultobj = 0;
17961 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17962 int result;
17963 void *argp1 = 0 ;
17964 int res1 = 0 ;
17965 PyObject *swig_obj[1] ;
17966
17967 if (!args) SWIG_fail;
17968 swig_obj[0] = args;
17969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17970 if (!SWIG_IsOK(res1)) {
17971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17972 }
17973 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17974 {
17975 PyThreadState* __tstate = wxPyBeginAllowThreads();
17976 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17977 wxPyEndAllowThreads(__tstate);
17978 if (PyErr_Occurred()) SWIG_fail;
17979 }
17980 resultobj = SWIG_From_int(static_cast< int >(result));
17981 return resultobj;
17982 fail:
17983 return NULL;
17984 }
17985
17986
17987 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17988 PyObject *obj;
17989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17990 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17991 return SWIG_Py_Void();
17992 }
17993
17994 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 return SWIG_Python_InitShadowInstance(args);
17996 }
17997
17998 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17999 PyObject *resultobj = 0;
18000 wxFileTypeInfo *arg1 = 0 ;
18001 wxFileType *result = 0 ;
18002 void *argp1 = 0 ;
18003 int res1 = 0 ;
18004 PyObject * obj0 = 0 ;
18005 char * kwnames[] = {
18006 (char *) "ftInfo", NULL
18007 };
18008
18009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18010 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18011 if (!SWIG_IsOK(res1)) {
18012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18013 }
18014 if (!argp1) {
18015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18016 }
18017 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18032 PyObject *resultobj = 0;
18033 wxFileType *arg1 = (wxFileType *) 0 ;
18034 void *argp1 = 0 ;
18035 int res1 = 0 ;
18036 PyObject *swig_obj[1] ;
18037
18038 if (!args) SWIG_fail;
18039 swig_obj[0] = args;
18040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18041 if (!SWIG_IsOK(res1)) {
18042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18043 }
18044 arg1 = reinterpret_cast< wxFileType * >(argp1);
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 delete arg1;
18048
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 resultobj = SWIG_Py_Void();
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18060 PyObject *resultobj = 0;
18061 wxFileType *arg1 = (wxFileType *) 0 ;
18062 PyObject *result = 0 ;
18063 void *argp1 = 0 ;
18064 int res1 = 0 ;
18065 PyObject *swig_obj[1] ;
18066
18067 if (!args) SWIG_fail;
18068 swig_obj[0] = args;
18069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18070 if (!SWIG_IsOK(res1)) {
18071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18072 }
18073 arg1 = reinterpret_cast< wxFileType * >(argp1);
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (PyObject *)wxFileType_GetMimeType(arg1);
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 resultobj = result;
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088 PyObject *resultobj = 0;
18089 wxFileType *arg1 = (wxFileType *) 0 ;
18090 PyObject *result = 0 ;
18091 void *argp1 = 0 ;
18092 int res1 = 0 ;
18093 PyObject *swig_obj[1] ;
18094
18095 if (!args) SWIG_fail;
18096 swig_obj[0] = args;
18097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18098 if (!SWIG_IsOK(res1)) {
18099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18100 }
18101 arg1 = reinterpret_cast< wxFileType * >(argp1);
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 resultobj = result;
18109 return resultobj;
18110 fail:
18111 return NULL;
18112 }
18113
18114
18115 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18116 PyObject *resultobj = 0;
18117 wxFileType *arg1 = (wxFileType *) 0 ;
18118 PyObject *result = 0 ;
18119 void *argp1 = 0 ;
18120 int res1 = 0 ;
18121 PyObject *swig_obj[1] ;
18122
18123 if (!args) SWIG_fail;
18124 swig_obj[0] = args;
18125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18126 if (!SWIG_IsOK(res1)) {
18127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18128 }
18129 arg1 = reinterpret_cast< wxFileType * >(argp1);
18130 {
18131 PyThreadState* __tstate = wxPyBeginAllowThreads();
18132 result = (PyObject *)wxFileType_GetExtensions(arg1);
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 resultobj = result;
18137 return resultobj;
18138 fail:
18139 return NULL;
18140 }
18141
18142
18143 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18144 PyObject *resultobj = 0;
18145 wxFileType *arg1 = (wxFileType *) 0 ;
18146 wxIcon *result = 0 ;
18147 void *argp1 = 0 ;
18148 int res1 = 0 ;
18149 PyObject *swig_obj[1] ;
18150
18151 if (!args) SWIG_fail;
18152 swig_obj[0] = args;
18153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18154 if (!SWIG_IsOK(res1)) {
18155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18156 }
18157 arg1 = reinterpret_cast< wxFileType * >(argp1);
18158 {
18159 PyThreadState* __tstate = wxPyBeginAllowThreads();
18160 result = (wxIcon *)wxFileType_GetIcon(arg1);
18161 wxPyEndAllowThreads(__tstate);
18162 if (PyErr_Occurred()) SWIG_fail;
18163 }
18164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18165 return resultobj;
18166 fail:
18167 return NULL;
18168 }
18169
18170
18171 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18172 PyObject *resultobj = 0;
18173 wxFileType *arg1 = (wxFileType *) 0 ;
18174 PyObject *result = 0 ;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 PyObject *swig_obj[1] ;
18178
18179 if (!args) SWIG_fail;
18180 swig_obj[0] = args;
18181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18184 }
18185 arg1 = reinterpret_cast< wxFileType * >(argp1);
18186 {
18187 PyThreadState* __tstate = wxPyBeginAllowThreads();
18188 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18189 wxPyEndAllowThreads(__tstate);
18190 if (PyErr_Occurred()) SWIG_fail;
18191 }
18192 resultobj = result;
18193 return resultobj;
18194 fail:
18195 return NULL;
18196 }
18197
18198
18199 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18200 PyObject *resultobj = 0;
18201 wxFileType *arg1 = (wxFileType *) 0 ;
18202 PyObject *result = 0 ;
18203 void *argp1 = 0 ;
18204 int res1 = 0 ;
18205 PyObject *swig_obj[1] ;
18206
18207 if (!args) SWIG_fail;
18208 swig_obj[0] = args;
18209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18210 if (!SWIG_IsOK(res1)) {
18211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18212 }
18213 arg1 = reinterpret_cast< wxFileType * >(argp1);
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (PyObject *)wxFileType_GetDescription(arg1);
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = result;
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18228 PyObject *resultobj = 0;
18229 wxFileType *arg1 = (wxFileType *) 0 ;
18230 wxString *arg2 = 0 ;
18231 wxString const &arg3_defvalue = wxPyEmptyString ;
18232 wxString *arg3 = (wxString *) &arg3_defvalue ;
18233 PyObject *result = 0 ;
18234 void *argp1 = 0 ;
18235 int res1 = 0 ;
18236 bool temp2 = false ;
18237 bool temp3 = false ;
18238 PyObject * obj0 = 0 ;
18239 PyObject * obj1 = 0 ;
18240 PyObject * obj2 = 0 ;
18241 char * kwnames[] = {
18242 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18243 };
18244
18245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18247 if (!SWIG_IsOK(res1)) {
18248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18249 }
18250 arg1 = reinterpret_cast< wxFileType * >(argp1);
18251 {
18252 arg2 = wxString_in_helper(obj1);
18253 if (arg2 == NULL) SWIG_fail;
18254 temp2 = true;
18255 }
18256 if (obj2) {
18257 {
18258 arg3 = wxString_in_helper(obj2);
18259 if (arg3 == NULL) SWIG_fail;
18260 temp3 = true;
18261 }
18262 }
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 resultobj = result;
18270 {
18271 if (temp2)
18272 delete arg2;
18273 }
18274 {
18275 if (temp3)
18276 delete arg3;
18277 }
18278 return resultobj;
18279 fail:
18280 {
18281 if (temp2)
18282 delete arg2;
18283 }
18284 {
18285 if (temp3)
18286 delete arg3;
18287 }
18288 return NULL;
18289 }
18290
18291
18292 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18293 PyObject *resultobj = 0;
18294 wxFileType *arg1 = (wxFileType *) 0 ;
18295 wxString *arg2 = 0 ;
18296 wxString const &arg3_defvalue = wxPyEmptyString ;
18297 wxString *arg3 = (wxString *) &arg3_defvalue ;
18298 PyObject *result = 0 ;
18299 void *argp1 = 0 ;
18300 int res1 = 0 ;
18301 bool temp2 = false ;
18302 bool temp3 = false ;
18303 PyObject * obj0 = 0 ;
18304 PyObject * obj1 = 0 ;
18305 PyObject * obj2 = 0 ;
18306 char * kwnames[] = {
18307 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18308 };
18309
18310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18312 if (!SWIG_IsOK(res1)) {
18313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18314 }
18315 arg1 = reinterpret_cast< wxFileType * >(argp1);
18316 {
18317 arg2 = wxString_in_helper(obj1);
18318 if (arg2 == NULL) SWIG_fail;
18319 temp2 = true;
18320 }
18321 if (obj2) {
18322 {
18323 arg3 = wxString_in_helper(obj2);
18324 if (arg3 == NULL) SWIG_fail;
18325 temp3 = true;
18326 }
18327 }
18328 {
18329 PyThreadState* __tstate = wxPyBeginAllowThreads();
18330 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18331 wxPyEndAllowThreads(__tstate);
18332 if (PyErr_Occurred()) SWIG_fail;
18333 }
18334 resultobj = result;
18335 {
18336 if (temp2)
18337 delete arg2;
18338 }
18339 {
18340 if (temp3)
18341 delete arg3;
18342 }
18343 return resultobj;
18344 fail:
18345 {
18346 if (temp2)
18347 delete arg2;
18348 }
18349 {
18350 if (temp3)
18351 delete arg3;
18352 }
18353 return NULL;
18354 }
18355
18356
18357 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18358 PyObject *resultobj = 0;
18359 wxFileType *arg1 = (wxFileType *) 0 ;
18360 wxString *arg2 = 0 ;
18361 wxString const &arg3_defvalue = wxPyEmptyString ;
18362 wxString *arg3 = (wxString *) &arg3_defvalue ;
18363 PyObject *result = 0 ;
18364 void *argp1 = 0 ;
18365 int res1 = 0 ;
18366 bool temp2 = false ;
18367 bool temp3 = false ;
18368 PyObject * obj0 = 0 ;
18369 PyObject * obj1 = 0 ;
18370 PyObject * obj2 = 0 ;
18371 char * kwnames[] = {
18372 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18373 };
18374
18375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18377 if (!SWIG_IsOK(res1)) {
18378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18379 }
18380 arg1 = reinterpret_cast< wxFileType * >(argp1);
18381 {
18382 arg2 = wxString_in_helper(obj1);
18383 if (arg2 == NULL) SWIG_fail;
18384 temp2 = true;
18385 }
18386 if (obj2) {
18387 {
18388 arg3 = wxString_in_helper(obj2);
18389 if (arg3 == NULL) SWIG_fail;
18390 temp3 = true;
18391 }
18392 }
18393 {
18394 PyThreadState* __tstate = wxPyBeginAllowThreads();
18395 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 resultobj = result;
18400 {
18401 if (temp2)
18402 delete arg2;
18403 }
18404 {
18405 if (temp3)
18406 delete arg3;
18407 }
18408 return resultobj;
18409 fail:
18410 {
18411 if (temp2)
18412 delete arg2;
18413 }
18414 {
18415 if (temp3)
18416 delete arg3;
18417 }
18418 return NULL;
18419 }
18420
18421
18422 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18423 PyObject *resultobj = 0;
18424 wxFileType *arg1 = (wxFileType *) 0 ;
18425 wxString *arg2 = 0 ;
18426 wxString *arg3 = 0 ;
18427 bool arg4 = (bool) true ;
18428 bool result;
18429 void *argp1 = 0 ;
18430 int res1 = 0 ;
18431 bool temp2 = false ;
18432 bool temp3 = false ;
18433 bool val4 ;
18434 int ecode4 = 0 ;
18435 PyObject * obj0 = 0 ;
18436 PyObject * obj1 = 0 ;
18437 PyObject * obj2 = 0 ;
18438 PyObject * obj3 = 0 ;
18439 char * kwnames[] = {
18440 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18441 };
18442
18443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18445 if (!SWIG_IsOK(res1)) {
18446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18447 }
18448 arg1 = reinterpret_cast< wxFileType * >(argp1);
18449 {
18450 arg2 = wxString_in_helper(obj1);
18451 if (arg2 == NULL) SWIG_fail;
18452 temp2 = true;
18453 }
18454 {
18455 arg3 = wxString_in_helper(obj2);
18456 if (arg3 == NULL) SWIG_fail;
18457 temp3 = true;
18458 }
18459 if (obj3) {
18460 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18461 if (!SWIG_IsOK(ecode4)) {
18462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18463 }
18464 arg4 = static_cast< bool >(val4);
18465 }
18466 {
18467 PyThreadState* __tstate = wxPyBeginAllowThreads();
18468 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18469 wxPyEndAllowThreads(__tstate);
18470 if (PyErr_Occurred()) SWIG_fail;
18471 }
18472 {
18473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18474 }
18475 {
18476 if (temp2)
18477 delete arg2;
18478 }
18479 {
18480 if (temp3)
18481 delete arg3;
18482 }
18483 return resultobj;
18484 fail:
18485 {
18486 if (temp2)
18487 delete arg2;
18488 }
18489 {
18490 if (temp3)
18491 delete arg3;
18492 }
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18498 PyObject *resultobj = 0;
18499 wxFileType *arg1 = (wxFileType *) 0 ;
18500 wxString const &arg2_defvalue = wxPyEmptyString ;
18501 wxString *arg2 = (wxString *) &arg2_defvalue ;
18502 int arg3 = (int) 0 ;
18503 bool result;
18504 void *argp1 = 0 ;
18505 int res1 = 0 ;
18506 bool temp2 = false ;
18507 int val3 ;
18508 int ecode3 = 0 ;
18509 PyObject * obj0 = 0 ;
18510 PyObject * obj1 = 0 ;
18511 PyObject * obj2 = 0 ;
18512 char * kwnames[] = {
18513 (char *) "self",(char *) "cmd",(char *) "index", NULL
18514 };
18515
18516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18518 if (!SWIG_IsOK(res1)) {
18519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18520 }
18521 arg1 = reinterpret_cast< wxFileType * >(argp1);
18522 if (obj1) {
18523 {
18524 arg2 = wxString_in_helper(obj1);
18525 if (arg2 == NULL) SWIG_fail;
18526 temp2 = true;
18527 }
18528 }
18529 if (obj2) {
18530 ecode3 = SWIG_AsVal_int(obj2, &val3);
18531 if (!SWIG_IsOK(ecode3)) {
18532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18533 }
18534 arg3 = static_cast< int >(val3);
18535 }
18536 {
18537 PyThreadState* __tstate = wxPyBeginAllowThreads();
18538 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18539 wxPyEndAllowThreads(__tstate);
18540 if (PyErr_Occurred()) SWIG_fail;
18541 }
18542 {
18543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18544 }
18545 {
18546 if (temp2)
18547 delete arg2;
18548 }
18549 return resultobj;
18550 fail:
18551 {
18552 if (temp2)
18553 delete arg2;
18554 }
18555 return NULL;
18556 }
18557
18558
18559 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18560 PyObject *resultobj = 0;
18561 wxFileType *arg1 = (wxFileType *) 0 ;
18562 bool result;
18563 void *argp1 = 0 ;
18564 int res1 = 0 ;
18565 PyObject *swig_obj[1] ;
18566
18567 if (!args) SWIG_fail;
18568 swig_obj[0] = args;
18569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18570 if (!SWIG_IsOK(res1)) {
18571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18572 }
18573 arg1 = reinterpret_cast< wxFileType * >(argp1);
18574 {
18575 PyThreadState* __tstate = wxPyBeginAllowThreads();
18576 result = (bool)(arg1)->Unassociate();
18577 wxPyEndAllowThreads(__tstate);
18578 if (PyErr_Occurred()) SWIG_fail;
18579 }
18580 {
18581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18582 }
18583 return resultobj;
18584 fail:
18585 return NULL;
18586 }
18587
18588
18589 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18590 PyObject *resultobj = 0;
18591 wxString *arg1 = 0 ;
18592 wxString *arg2 = 0 ;
18593 wxString const &arg3_defvalue = wxPyEmptyString ;
18594 wxString *arg3 = (wxString *) &arg3_defvalue ;
18595 wxString result;
18596 bool temp1 = false ;
18597 bool temp2 = false ;
18598 bool temp3 = false ;
18599 PyObject * obj0 = 0 ;
18600 PyObject * obj1 = 0 ;
18601 PyObject * obj2 = 0 ;
18602 char * kwnames[] = {
18603 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18604 };
18605
18606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18607 {
18608 arg1 = wxString_in_helper(obj0);
18609 if (arg1 == NULL) SWIG_fail;
18610 temp1 = true;
18611 }
18612 {
18613 arg2 = wxString_in_helper(obj1);
18614 if (arg2 == NULL) SWIG_fail;
18615 temp2 = true;
18616 }
18617 if (obj2) {
18618 {
18619 arg3 = wxString_in_helper(obj2);
18620 if (arg3 == NULL) SWIG_fail;
18621 temp3 = true;
18622 }
18623 }
18624 {
18625 PyThreadState* __tstate = wxPyBeginAllowThreads();
18626 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18627 wxPyEndAllowThreads(__tstate);
18628 if (PyErr_Occurred()) SWIG_fail;
18629 }
18630 {
18631 #if wxUSE_UNICODE
18632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18633 #else
18634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18635 #endif
18636 }
18637 {
18638 if (temp1)
18639 delete arg1;
18640 }
18641 {
18642 if (temp2)
18643 delete arg2;
18644 }
18645 {
18646 if (temp3)
18647 delete arg3;
18648 }
18649 return resultobj;
18650 fail:
18651 {
18652 if (temp1)
18653 delete arg1;
18654 }
18655 {
18656 if (temp2)
18657 delete arg2;
18658 }
18659 {
18660 if (temp3)
18661 delete arg3;
18662 }
18663 return NULL;
18664 }
18665
18666
18667 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18668 PyObject *obj;
18669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18670 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18671 return SWIG_Py_Void();
18672 }
18673
18674 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18675 return SWIG_Python_InitShadowInstance(args);
18676 }
18677
18678 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18679 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18680 return 1;
18681 }
18682
18683
18684 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18685 PyObject *pyobj = 0;
18686
18687 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18688 return pyobj;
18689 }
18690
18691
18692 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj = 0;
18694 wxString *arg1 = 0 ;
18695 wxString *arg2 = 0 ;
18696 bool result;
18697 bool temp1 = false ;
18698 bool temp2 = false ;
18699 PyObject * obj0 = 0 ;
18700 PyObject * obj1 = 0 ;
18701 char * kwnames[] = {
18702 (char *) "mimeType",(char *) "wildcard", NULL
18703 };
18704
18705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18706 {
18707 arg1 = wxString_in_helper(obj0);
18708 if (arg1 == NULL) SWIG_fail;
18709 temp1 = true;
18710 }
18711 {
18712 arg2 = wxString_in_helper(obj1);
18713 if (arg2 == NULL) SWIG_fail;
18714 temp2 = true;
18715 }
18716 {
18717 PyThreadState* __tstate = wxPyBeginAllowThreads();
18718 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18719 wxPyEndAllowThreads(__tstate);
18720 if (PyErr_Occurred()) SWIG_fail;
18721 }
18722 {
18723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18724 }
18725 {
18726 if (temp1)
18727 delete arg1;
18728 }
18729 {
18730 if (temp2)
18731 delete arg2;
18732 }
18733 return resultobj;
18734 fail:
18735 {
18736 if (temp1)
18737 delete arg1;
18738 }
18739 {
18740 if (temp2)
18741 delete arg2;
18742 }
18743 return NULL;
18744 }
18745
18746
18747 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18748 PyObject *resultobj = 0;
18749 wxMimeTypesManager *result = 0 ;
18750
18751 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18752 {
18753 PyThreadState* __tstate = wxPyBeginAllowThreads();
18754 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18755 wxPyEndAllowThreads(__tstate);
18756 if (PyErr_Occurred()) SWIG_fail;
18757 }
18758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18759 return resultobj;
18760 fail:
18761 return NULL;
18762 }
18763
18764
18765 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18766 PyObject *resultobj = 0;
18767 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18768 int arg2 = (int) wxMAILCAP_ALL ;
18769 wxString const &arg3_defvalue = wxPyEmptyString ;
18770 wxString *arg3 = (wxString *) &arg3_defvalue ;
18771 void *argp1 = 0 ;
18772 int res1 = 0 ;
18773 int val2 ;
18774 int ecode2 = 0 ;
18775 bool temp3 = false ;
18776 PyObject * obj0 = 0 ;
18777 PyObject * obj1 = 0 ;
18778 PyObject * obj2 = 0 ;
18779 char * kwnames[] = {
18780 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18781 };
18782
18783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18785 if (!SWIG_IsOK(res1)) {
18786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18787 }
18788 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18789 if (obj1) {
18790 ecode2 = SWIG_AsVal_int(obj1, &val2);
18791 if (!SWIG_IsOK(ecode2)) {
18792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18793 }
18794 arg2 = static_cast< int >(val2);
18795 }
18796 if (obj2) {
18797 {
18798 arg3 = wxString_in_helper(obj2);
18799 if (arg3 == NULL) SWIG_fail;
18800 temp3 = true;
18801 }
18802 }
18803 {
18804 PyThreadState* __tstate = wxPyBeginAllowThreads();
18805 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18806 wxPyEndAllowThreads(__tstate);
18807 if (PyErr_Occurred()) SWIG_fail;
18808 }
18809 resultobj = SWIG_Py_Void();
18810 {
18811 if (temp3)
18812 delete arg3;
18813 }
18814 return resultobj;
18815 fail:
18816 {
18817 if (temp3)
18818 delete arg3;
18819 }
18820 return NULL;
18821 }
18822
18823
18824 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 PyObject *resultobj = 0;
18826 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18827 void *argp1 = 0 ;
18828 int res1 = 0 ;
18829 PyObject *swig_obj[1] ;
18830
18831 if (!args) SWIG_fail;
18832 swig_obj[0] = args;
18833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18834 if (!SWIG_IsOK(res1)) {
18835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18836 }
18837 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18838 {
18839 PyThreadState* __tstate = wxPyBeginAllowThreads();
18840 (arg1)->ClearData();
18841 wxPyEndAllowThreads(__tstate);
18842 if (PyErr_Occurred()) SWIG_fail;
18843 }
18844 resultobj = SWIG_Py_Void();
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj = 0;
18853 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18854 wxString *arg2 = 0 ;
18855 wxFileType *result = 0 ;
18856 void *argp1 = 0 ;
18857 int res1 = 0 ;
18858 bool temp2 = false ;
18859 PyObject * obj0 = 0 ;
18860 PyObject * obj1 = 0 ;
18861 char * kwnames[] = {
18862 (char *) "self",(char *) "ext", NULL
18863 };
18864
18865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18867 if (!SWIG_IsOK(res1)) {
18868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18869 }
18870 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18871 {
18872 arg2 = wxString_in_helper(obj1);
18873 if (arg2 == NULL) SWIG_fail;
18874 temp2 = true;
18875 }
18876 {
18877 PyThreadState* __tstate = wxPyBeginAllowThreads();
18878 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18879 wxPyEndAllowThreads(__tstate);
18880 if (PyErr_Occurred()) SWIG_fail;
18881 }
18882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18883 {
18884 if (temp2)
18885 delete arg2;
18886 }
18887 return resultobj;
18888 fail:
18889 {
18890 if (temp2)
18891 delete arg2;
18892 }
18893 return NULL;
18894 }
18895
18896
18897 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18898 PyObject *resultobj = 0;
18899 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18900 wxString *arg2 = 0 ;
18901 wxFileType *result = 0 ;
18902 void *argp1 = 0 ;
18903 int res1 = 0 ;
18904 bool temp2 = false ;
18905 PyObject * obj0 = 0 ;
18906 PyObject * obj1 = 0 ;
18907 char * kwnames[] = {
18908 (char *) "self",(char *) "mimeType", NULL
18909 };
18910
18911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18913 if (!SWIG_IsOK(res1)) {
18914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18915 }
18916 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18917 {
18918 arg2 = wxString_in_helper(obj1);
18919 if (arg2 == NULL) SWIG_fail;
18920 temp2 = true;
18921 }
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18929 {
18930 if (temp2)
18931 delete arg2;
18932 }
18933 return resultobj;
18934 fail:
18935 {
18936 if (temp2)
18937 delete arg2;
18938 }
18939 return NULL;
18940 }
18941
18942
18943 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18944 PyObject *resultobj = 0;
18945 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18946 wxString *arg2 = 0 ;
18947 bool arg3 = (bool) false ;
18948 bool result;
18949 void *argp1 = 0 ;
18950 int res1 = 0 ;
18951 bool temp2 = false ;
18952 bool val3 ;
18953 int ecode3 = 0 ;
18954 PyObject * obj0 = 0 ;
18955 PyObject * obj1 = 0 ;
18956 PyObject * obj2 = 0 ;
18957 char * kwnames[] = {
18958 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18959 };
18960
18961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18963 if (!SWIG_IsOK(res1)) {
18964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18965 }
18966 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18967 {
18968 arg2 = wxString_in_helper(obj1);
18969 if (arg2 == NULL) SWIG_fail;
18970 temp2 = true;
18971 }
18972 if (obj2) {
18973 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18974 if (!SWIG_IsOK(ecode3)) {
18975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18976 }
18977 arg3 = static_cast< bool >(val3);
18978 }
18979 {
18980 PyThreadState* __tstate = wxPyBeginAllowThreads();
18981 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18982 wxPyEndAllowThreads(__tstate);
18983 if (PyErr_Occurred()) SWIG_fail;
18984 }
18985 {
18986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18987 }
18988 {
18989 if (temp2)
18990 delete arg2;
18991 }
18992 return resultobj;
18993 fail:
18994 {
18995 if (temp2)
18996 delete arg2;
18997 }
18998 return NULL;
18999 }
19000
19001
19002 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19003 PyObject *resultobj = 0;
19004 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19005 wxString *arg2 = 0 ;
19006 bool result;
19007 void *argp1 = 0 ;
19008 int res1 = 0 ;
19009 bool temp2 = false ;
19010 PyObject * obj0 = 0 ;
19011 PyObject * obj1 = 0 ;
19012 char * kwnames[] = {
19013 (char *) "self",(char *) "filename", NULL
19014 };
19015
19016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19018 if (!SWIG_IsOK(res1)) {
19019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19020 }
19021 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19022 {
19023 arg2 = wxString_in_helper(obj1);
19024 if (arg2 == NULL) SWIG_fail;
19025 temp2 = true;
19026 }
19027 {
19028 PyThreadState* __tstate = wxPyBeginAllowThreads();
19029 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19030 wxPyEndAllowThreads(__tstate);
19031 if (PyErr_Occurred()) SWIG_fail;
19032 }
19033 {
19034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19035 }
19036 {
19037 if (temp2)
19038 delete arg2;
19039 }
19040 return resultobj;
19041 fail:
19042 {
19043 if (temp2)
19044 delete arg2;
19045 }
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19051 PyObject *resultobj = 0;
19052 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19053 PyObject *result = 0 ;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 PyObject *swig_obj[1] ;
19057
19058 if (!args) SWIG_fail;
19059 swig_obj[0] = args;
19060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19061 if (!SWIG_IsOK(res1)) {
19062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19063 }
19064 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19065 {
19066 PyThreadState* __tstate = wxPyBeginAllowThreads();
19067 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19068 wxPyEndAllowThreads(__tstate);
19069 if (PyErr_Occurred()) SWIG_fail;
19070 }
19071 resultobj = result;
19072 return resultobj;
19073 fail:
19074 return NULL;
19075 }
19076
19077
19078 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19079 PyObject *resultobj = 0;
19080 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19081 wxFileTypeInfo *arg2 = 0 ;
19082 void *argp1 = 0 ;
19083 int res1 = 0 ;
19084 void *argp2 = 0 ;
19085 int res2 = 0 ;
19086 PyObject * obj0 = 0 ;
19087 PyObject * obj1 = 0 ;
19088 char * kwnames[] = {
19089 (char *) "self",(char *) "ft", NULL
19090 };
19091
19092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19094 if (!SWIG_IsOK(res1)) {
19095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19096 }
19097 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19099 if (!SWIG_IsOK(res2)) {
19100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19101 }
19102 if (!argp2) {
19103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19104 }
19105 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19106 {
19107 PyThreadState* __tstate = wxPyBeginAllowThreads();
19108 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19109 wxPyEndAllowThreads(__tstate);
19110 if (PyErr_Occurred()) SWIG_fail;
19111 }
19112 resultobj = SWIG_Py_Void();
19113 return resultobj;
19114 fail:
19115 return NULL;
19116 }
19117
19118
19119 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19120 PyObject *resultobj = 0;
19121 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19122 wxFileTypeInfo *arg2 = 0 ;
19123 wxFileType *result = 0 ;
19124 void *argp1 = 0 ;
19125 int res1 = 0 ;
19126 void *argp2 = 0 ;
19127 int res2 = 0 ;
19128 PyObject * obj0 = 0 ;
19129 PyObject * obj1 = 0 ;
19130 char * kwnames[] = {
19131 (char *) "self",(char *) "ftInfo", NULL
19132 };
19133
19134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19136 if (!SWIG_IsOK(res1)) {
19137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19138 }
19139 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19140 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19141 if (!SWIG_IsOK(res2)) {
19142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19143 }
19144 if (!argp2) {
19145 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19146 }
19147 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19155 return resultobj;
19156 fail:
19157 return NULL;
19158 }
19159
19160
19161 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19162 PyObject *resultobj = 0;
19163 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19164 wxFileType *arg2 = (wxFileType *) 0 ;
19165 bool result;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 void *argp2 = 0 ;
19169 int res2 = 0 ;
19170 PyObject * obj0 = 0 ;
19171 PyObject * obj1 = 0 ;
19172 char * kwnames[] = {
19173 (char *) "self",(char *) "ft", NULL
19174 };
19175
19176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19178 if (!SWIG_IsOK(res1)) {
19179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19180 }
19181 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19183 if (!SWIG_IsOK(res2)) {
19184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19185 }
19186 arg2 = reinterpret_cast< wxFileType * >(argp2);
19187 {
19188 PyThreadState* __tstate = wxPyBeginAllowThreads();
19189 result = (bool)(arg1)->Unassociate(arg2);
19190 wxPyEndAllowThreads(__tstate);
19191 if (PyErr_Occurred()) SWIG_fail;
19192 }
19193 {
19194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19195 }
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19203 PyObject *resultobj = 0;
19204 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19205 void *argp1 = 0 ;
19206 int res1 = 0 ;
19207 PyObject *swig_obj[1] ;
19208
19209 if (!args) SWIG_fail;
19210 swig_obj[0] = args;
19211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19214 }
19215 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 delete arg1;
19219
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 resultobj = SWIG_Py_Void();
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19231 PyObject *obj;
19232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19233 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19234 return SWIG_Py_Void();
19235 }
19236
19237 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19238 return SWIG_Python_InitShadowInstance(args);
19239 }
19240
19241 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19242 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19243 return 1;
19244 }
19245
19246
19247 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19248 PyObject *pyobj = 0;
19249
19250 {
19251 #if wxUSE_UNICODE
19252 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19253 #else
19254 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19255 #endif
19256 }
19257 return pyobj;
19258 }
19259
19260
19261 SWIGINTERN int ART_MENU_set(PyObject *) {
19262 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19263 return 1;
19264 }
19265
19266
19267 SWIGINTERN PyObject *ART_MENU_get(void) {
19268 PyObject *pyobj = 0;
19269
19270 {
19271 #if wxUSE_UNICODE
19272 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19273 #else
19274 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19275 #endif
19276 }
19277 return pyobj;
19278 }
19279
19280
19281 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19282 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19283 return 1;
19284 }
19285
19286
19287 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19288 PyObject *pyobj = 0;
19289
19290 {
19291 #if wxUSE_UNICODE
19292 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19293 #else
19294 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19295 #endif
19296 }
19297 return pyobj;
19298 }
19299
19300
19301 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19302 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19303 return 1;
19304 }
19305
19306
19307 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19308 PyObject *pyobj = 0;
19309
19310 {
19311 #if wxUSE_UNICODE
19312 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19313 #else
19314 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19315 #endif
19316 }
19317 return pyobj;
19318 }
19319
19320
19321 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19322 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19323 return 1;
19324 }
19325
19326
19327 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19328 PyObject *pyobj = 0;
19329
19330 {
19331 #if wxUSE_UNICODE
19332 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19333 #else
19334 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19335 #endif
19336 }
19337 return pyobj;
19338 }
19339
19340
19341 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19342 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19343 return 1;
19344 }
19345
19346
19347 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19348 PyObject *pyobj = 0;
19349
19350 {
19351 #if wxUSE_UNICODE
19352 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19353 #else
19354 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19355 #endif
19356 }
19357 return pyobj;
19358 }
19359
19360
19361 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19362 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19363 return 1;
19364 }
19365
19366
19367 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19368 PyObject *pyobj = 0;
19369
19370 {
19371 #if wxUSE_UNICODE
19372 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19373 #else
19374 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19375 #endif
19376 }
19377 return pyobj;
19378 }
19379
19380
19381 SWIGINTERN int ART_OTHER_set(PyObject *) {
19382 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19383 return 1;
19384 }
19385
19386
19387 SWIGINTERN PyObject *ART_OTHER_get(void) {
19388 PyObject *pyobj = 0;
19389
19390 {
19391 #if wxUSE_UNICODE
19392 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19393 #else
19394 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19395 #endif
19396 }
19397 return pyobj;
19398 }
19399
19400
19401 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19402 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19403 return 1;
19404 }
19405
19406
19407 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19408 PyObject *pyobj = 0;
19409
19410 {
19411 #if wxUSE_UNICODE
19412 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19413 #else
19414 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19415 #endif
19416 }
19417 return pyobj;
19418 }
19419
19420
19421 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19422 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19423 return 1;
19424 }
19425
19426
19427 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19428 PyObject *pyobj = 0;
19429
19430 {
19431 #if wxUSE_UNICODE
19432 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19433 #else
19434 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19435 #endif
19436 }
19437 return pyobj;
19438 }
19439
19440
19441 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19442 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19443 return 1;
19444 }
19445
19446
19447 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19448 PyObject *pyobj = 0;
19449
19450 {
19451 #if wxUSE_UNICODE
19452 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19453 #else
19454 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19455 #endif
19456 }
19457 return pyobj;
19458 }
19459
19460
19461 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19462 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19463 return 1;
19464 }
19465
19466
19467 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19468 PyObject *pyobj = 0;
19469
19470 {
19471 #if wxUSE_UNICODE
19472 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19473 #else
19474 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19475 #endif
19476 }
19477 return pyobj;
19478 }
19479
19480
19481 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19482 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19483 return 1;
19484 }
19485
19486
19487 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19488 PyObject *pyobj = 0;
19489
19490 {
19491 #if wxUSE_UNICODE
19492 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19493 #else
19494 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19495 #endif
19496 }
19497 return pyobj;
19498 }
19499
19500
19501 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19502 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19503 return 1;
19504 }
19505
19506
19507 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19508 PyObject *pyobj = 0;
19509
19510 {
19511 #if wxUSE_UNICODE
19512 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19513 #else
19514 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19515 #endif
19516 }
19517 return pyobj;
19518 }
19519
19520
19521 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19522 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19523 return 1;
19524 }
19525
19526
19527 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19528 PyObject *pyobj = 0;
19529
19530 {
19531 #if wxUSE_UNICODE
19532 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19533 #else
19534 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19535 #endif
19536 }
19537 return pyobj;
19538 }
19539
19540
19541 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19542 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19543 return 1;
19544 }
19545
19546
19547 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19548 PyObject *pyobj = 0;
19549
19550 {
19551 #if wxUSE_UNICODE
19552 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19553 #else
19554 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19555 #endif
19556 }
19557 return pyobj;
19558 }
19559
19560
19561 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19562 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19563 return 1;
19564 }
19565
19566
19567 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19568 PyObject *pyobj = 0;
19569
19570 {
19571 #if wxUSE_UNICODE
19572 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19573 #else
19574 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19575 #endif
19576 }
19577 return pyobj;
19578 }
19579
19580
19581 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19582 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19583 return 1;
19584 }
19585
19586
19587 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19588 PyObject *pyobj = 0;
19589
19590 {
19591 #if wxUSE_UNICODE
19592 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19593 #else
19594 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19595 #endif
19596 }
19597 return pyobj;
19598 }
19599
19600
19601 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19602 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19603 return 1;
19604 }
19605
19606
19607 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19608 PyObject *pyobj = 0;
19609
19610 {
19611 #if wxUSE_UNICODE
19612 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19613 #else
19614 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19615 #endif
19616 }
19617 return pyobj;
19618 }
19619
19620
19621 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19622 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19623 return 1;
19624 }
19625
19626
19627 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19628 PyObject *pyobj = 0;
19629
19630 {
19631 #if wxUSE_UNICODE
19632 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19633 #else
19634 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19635 #endif
19636 }
19637 return pyobj;
19638 }
19639
19640
19641 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19642 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19643 return 1;
19644 }
19645
19646
19647 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19648 PyObject *pyobj = 0;
19649
19650 {
19651 #if wxUSE_UNICODE
19652 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19653 #else
19654 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19655 #endif
19656 }
19657 return pyobj;
19658 }
19659
19660
19661 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19662 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19663 return 1;
19664 }
19665
19666
19667 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19668 PyObject *pyobj = 0;
19669
19670 {
19671 #if wxUSE_UNICODE
19672 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19673 #else
19674 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19675 #endif
19676 }
19677 return pyobj;
19678 }
19679
19680
19681 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19682 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19683 return 1;
19684 }
19685
19686
19687 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19688 PyObject *pyobj = 0;
19689
19690 {
19691 #if wxUSE_UNICODE
19692 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19693 #else
19694 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19695 #endif
19696 }
19697 return pyobj;
19698 }
19699
19700
19701 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19702 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19703 return 1;
19704 }
19705
19706
19707 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19708 PyObject *pyobj = 0;
19709
19710 {
19711 #if wxUSE_UNICODE
19712 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19713 #else
19714 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19715 #endif
19716 }
19717 return pyobj;
19718 }
19719
19720
19721 SWIGINTERN int ART_PRINT_set(PyObject *) {
19722 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19723 return 1;
19724 }
19725
19726
19727 SWIGINTERN PyObject *ART_PRINT_get(void) {
19728 PyObject *pyobj = 0;
19729
19730 {
19731 #if wxUSE_UNICODE
19732 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19733 #else
19734 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19735 #endif
19736 }
19737 return pyobj;
19738 }
19739
19740
19741 SWIGINTERN int ART_HELP_set(PyObject *) {
19742 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19743 return 1;
19744 }
19745
19746
19747 SWIGINTERN PyObject *ART_HELP_get(void) {
19748 PyObject *pyobj = 0;
19749
19750 {
19751 #if wxUSE_UNICODE
19752 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19753 #else
19754 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19755 #endif
19756 }
19757 return pyobj;
19758 }
19759
19760
19761 SWIGINTERN int ART_TIP_set(PyObject *) {
19762 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19763 return 1;
19764 }
19765
19766
19767 SWIGINTERN PyObject *ART_TIP_get(void) {
19768 PyObject *pyobj = 0;
19769
19770 {
19771 #if wxUSE_UNICODE
19772 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19773 #else
19774 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19775 #endif
19776 }
19777 return pyobj;
19778 }
19779
19780
19781 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19782 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19783 return 1;
19784 }
19785
19786
19787 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19788 PyObject *pyobj = 0;
19789
19790 {
19791 #if wxUSE_UNICODE
19792 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19793 #else
19794 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19795 #endif
19796 }
19797 return pyobj;
19798 }
19799
19800
19801 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19802 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19803 return 1;
19804 }
19805
19806
19807 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19808 PyObject *pyobj = 0;
19809
19810 {
19811 #if wxUSE_UNICODE
19812 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19813 #else
19814 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19815 #endif
19816 }
19817 return pyobj;
19818 }
19819
19820
19821 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19822 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19823 return 1;
19824 }
19825
19826
19827 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19828 PyObject *pyobj = 0;
19829
19830 {
19831 #if wxUSE_UNICODE
19832 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19833 #else
19834 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19835 #endif
19836 }
19837 return pyobj;
19838 }
19839
19840
19841 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19842 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19843 return 1;
19844 }
19845
19846
19847 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19848 PyObject *pyobj = 0;
19849
19850 {
19851 #if wxUSE_UNICODE
19852 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19853 #else
19854 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19855 #endif
19856 }
19857 return pyobj;
19858 }
19859
19860
19861 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19862 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19863 return 1;
19864 }
19865
19866
19867 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19868 PyObject *pyobj = 0;
19869
19870 {
19871 #if wxUSE_UNICODE
19872 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19873 #else
19874 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19875 #endif
19876 }
19877 return pyobj;
19878 }
19879
19880
19881 SWIGINTERN int ART_CDROM_set(PyObject *) {
19882 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19883 return 1;
19884 }
19885
19886
19887 SWIGINTERN PyObject *ART_CDROM_get(void) {
19888 PyObject *pyobj = 0;
19889
19890 {
19891 #if wxUSE_UNICODE
19892 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19893 #else
19894 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19895 #endif
19896 }
19897 return pyobj;
19898 }
19899
19900
19901 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19902 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19903 return 1;
19904 }
19905
19906
19907 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19908 PyObject *pyobj = 0;
19909
19910 {
19911 #if wxUSE_UNICODE
19912 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19913 #else
19914 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19915 #endif
19916 }
19917 return pyobj;
19918 }
19919
19920
19921 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19922 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19923 return 1;
19924 }
19925
19926
19927 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19928 PyObject *pyobj = 0;
19929
19930 {
19931 #if wxUSE_UNICODE
19932 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19933 #else
19934 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19935 #endif
19936 }
19937 return pyobj;
19938 }
19939
19940
19941 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19942 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19943 return 1;
19944 }
19945
19946
19947 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19948 PyObject *pyobj = 0;
19949
19950 {
19951 #if wxUSE_UNICODE
19952 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19953 #else
19954 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19955 #endif
19956 }
19957 return pyobj;
19958 }
19959
19960
19961 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19962 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19963 return 1;
19964 }
19965
19966
19967 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19968 PyObject *pyobj = 0;
19969
19970 {
19971 #if wxUSE_UNICODE
19972 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19973 #else
19974 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19975 #endif
19976 }
19977 return pyobj;
19978 }
19979
19980
19981 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19982 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19983 return 1;
19984 }
19985
19986
19987 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19988 PyObject *pyobj = 0;
19989
19990 {
19991 #if wxUSE_UNICODE
19992 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19993 #else
19994 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19995 #endif
19996 }
19997 return pyobj;
19998 }
19999
20000
20001 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20002 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20003 return 1;
20004 }
20005
20006
20007 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20008 PyObject *pyobj = 0;
20009
20010 {
20011 #if wxUSE_UNICODE
20012 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20013 #else
20014 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20015 #endif
20016 }
20017 return pyobj;
20018 }
20019
20020
20021 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20022 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20023 return 1;
20024 }
20025
20026
20027 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20028 PyObject *pyobj = 0;
20029
20030 {
20031 #if wxUSE_UNICODE
20032 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20033 #else
20034 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20035 #endif
20036 }
20037 return pyobj;
20038 }
20039
20040
20041 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20042 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20043 return 1;
20044 }
20045
20046
20047 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20048 PyObject *pyobj = 0;
20049
20050 {
20051 #if wxUSE_UNICODE
20052 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20053 #else
20054 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20055 #endif
20056 }
20057 return pyobj;
20058 }
20059
20060
20061 SWIGINTERN int ART_ERROR_set(PyObject *) {
20062 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20063 return 1;
20064 }
20065
20066
20067 SWIGINTERN PyObject *ART_ERROR_get(void) {
20068 PyObject *pyobj = 0;
20069
20070 {
20071 #if wxUSE_UNICODE
20072 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20073 #else
20074 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20075 #endif
20076 }
20077 return pyobj;
20078 }
20079
20080
20081 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20082 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20083 return 1;
20084 }
20085
20086
20087 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20088 PyObject *pyobj = 0;
20089
20090 {
20091 #if wxUSE_UNICODE
20092 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20093 #else
20094 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20095 #endif
20096 }
20097 return pyobj;
20098 }
20099
20100
20101 SWIGINTERN int ART_WARNING_set(PyObject *) {
20102 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20103 return 1;
20104 }
20105
20106
20107 SWIGINTERN PyObject *ART_WARNING_get(void) {
20108 PyObject *pyobj = 0;
20109
20110 {
20111 #if wxUSE_UNICODE
20112 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20113 #else
20114 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20115 #endif
20116 }
20117 return pyobj;
20118 }
20119
20120
20121 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20122 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20123 return 1;
20124 }
20125
20126
20127 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20128 PyObject *pyobj = 0;
20129
20130 {
20131 #if wxUSE_UNICODE
20132 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20133 #else
20134 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20135 #endif
20136 }
20137 return pyobj;
20138 }
20139
20140
20141 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20142 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20143 return 1;
20144 }
20145
20146
20147 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20148 PyObject *pyobj = 0;
20149
20150 {
20151 #if wxUSE_UNICODE
20152 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20153 #else
20154 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20155 #endif
20156 }
20157 return pyobj;
20158 }
20159
20160
20161 SWIGINTERN int ART_COPY_set(PyObject *) {
20162 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20163 return 1;
20164 }
20165
20166
20167 SWIGINTERN PyObject *ART_COPY_get(void) {
20168 PyObject *pyobj = 0;
20169
20170 {
20171 #if wxUSE_UNICODE
20172 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20173 #else
20174 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20175 #endif
20176 }
20177 return pyobj;
20178 }
20179
20180
20181 SWIGINTERN int ART_CUT_set(PyObject *) {
20182 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20183 return 1;
20184 }
20185
20186
20187 SWIGINTERN PyObject *ART_CUT_get(void) {
20188 PyObject *pyobj = 0;
20189
20190 {
20191 #if wxUSE_UNICODE
20192 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20193 #else
20194 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20195 #endif
20196 }
20197 return pyobj;
20198 }
20199
20200
20201 SWIGINTERN int ART_PASTE_set(PyObject *) {
20202 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20203 return 1;
20204 }
20205
20206
20207 SWIGINTERN PyObject *ART_PASTE_get(void) {
20208 PyObject *pyobj = 0;
20209
20210 {
20211 #if wxUSE_UNICODE
20212 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20213 #else
20214 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20215 #endif
20216 }
20217 return pyobj;
20218 }
20219
20220
20221 SWIGINTERN int ART_DELETE_set(PyObject *) {
20222 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20223 return 1;
20224 }
20225
20226
20227 SWIGINTERN PyObject *ART_DELETE_get(void) {
20228 PyObject *pyobj = 0;
20229
20230 {
20231 #if wxUSE_UNICODE
20232 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20233 #else
20234 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20235 #endif
20236 }
20237 return pyobj;
20238 }
20239
20240
20241 SWIGINTERN int ART_NEW_set(PyObject *) {
20242 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20243 return 1;
20244 }
20245
20246
20247 SWIGINTERN PyObject *ART_NEW_get(void) {
20248 PyObject *pyobj = 0;
20249
20250 {
20251 #if wxUSE_UNICODE
20252 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20253 #else
20254 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20255 #endif
20256 }
20257 return pyobj;
20258 }
20259
20260
20261 SWIGINTERN int ART_UNDO_set(PyObject *) {
20262 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20263 return 1;
20264 }
20265
20266
20267 SWIGINTERN PyObject *ART_UNDO_get(void) {
20268 PyObject *pyobj = 0;
20269
20270 {
20271 #if wxUSE_UNICODE
20272 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20273 #else
20274 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20275 #endif
20276 }
20277 return pyobj;
20278 }
20279
20280
20281 SWIGINTERN int ART_REDO_set(PyObject *) {
20282 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20283 return 1;
20284 }
20285
20286
20287 SWIGINTERN PyObject *ART_REDO_get(void) {
20288 PyObject *pyobj = 0;
20289
20290 {
20291 #if wxUSE_UNICODE
20292 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20293 #else
20294 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20295 #endif
20296 }
20297 return pyobj;
20298 }
20299
20300
20301 SWIGINTERN int ART_QUIT_set(PyObject *) {
20302 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20303 return 1;
20304 }
20305
20306
20307 SWIGINTERN PyObject *ART_QUIT_get(void) {
20308 PyObject *pyobj = 0;
20309
20310 {
20311 #if wxUSE_UNICODE
20312 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20313 #else
20314 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20315 #endif
20316 }
20317 return pyobj;
20318 }
20319
20320
20321 SWIGINTERN int ART_FIND_set(PyObject *) {
20322 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20323 return 1;
20324 }
20325
20326
20327 SWIGINTERN PyObject *ART_FIND_get(void) {
20328 PyObject *pyobj = 0;
20329
20330 {
20331 #if wxUSE_UNICODE
20332 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20333 #else
20334 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20335 #endif
20336 }
20337 return pyobj;
20338 }
20339
20340
20341 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20342 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20343 return 1;
20344 }
20345
20346
20347 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20348 PyObject *pyobj = 0;
20349
20350 {
20351 #if wxUSE_UNICODE
20352 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20353 #else
20354 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20355 #endif
20356 }
20357 return pyobj;
20358 }
20359
20360
20361 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20362 PyObject *resultobj = 0;
20363 wxPyArtProvider *result = 0 ;
20364
20365 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20366 {
20367 if (!wxPyCheckForApp()) SWIG_fail;
20368 PyThreadState* __tstate = wxPyBeginAllowThreads();
20369 result = (wxPyArtProvider *)new wxPyArtProvider();
20370 wxPyEndAllowThreads(__tstate);
20371 if (PyErr_Occurred()) SWIG_fail;
20372 }
20373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20374 return resultobj;
20375 fail:
20376 return NULL;
20377 }
20378
20379
20380 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20381 PyObject *resultobj = 0;
20382 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20383 void *argp1 = 0 ;
20384 int res1 = 0 ;
20385 PyObject *swig_obj[1] ;
20386
20387 if (!args) SWIG_fail;
20388 swig_obj[0] = args;
20389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20390 if (!SWIG_IsOK(res1)) {
20391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20392 }
20393 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 delete arg1;
20397
20398 wxPyEndAllowThreads(__tstate);
20399 if (PyErr_Occurred()) SWIG_fail;
20400 }
20401 resultobj = SWIG_Py_Void();
20402 return resultobj;
20403 fail:
20404 return NULL;
20405 }
20406
20407
20408 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20409 PyObject *resultobj = 0;
20410 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20411 PyObject *arg2 = (PyObject *) 0 ;
20412 PyObject *arg3 = (PyObject *) 0 ;
20413 void *argp1 = 0 ;
20414 int res1 = 0 ;
20415 PyObject * obj0 = 0 ;
20416 PyObject * obj1 = 0 ;
20417 PyObject * obj2 = 0 ;
20418 char * kwnames[] = {
20419 (char *) "self",(char *) "self",(char *) "_class", NULL
20420 };
20421
20422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20424 if (!SWIG_IsOK(res1)) {
20425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20426 }
20427 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20428 arg2 = obj1;
20429 arg3 = obj2;
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 (arg1)->_setCallbackInfo(arg2,arg3);
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 resultobj = SWIG_Py_Void();
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20444 PyObject *resultobj = 0;
20445 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20446 int res1 = 0 ;
20447 PyObject * obj0 = 0 ;
20448 char * kwnames[] = {
20449 (char *) "provider", NULL
20450 };
20451
20452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20453 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20454 if (!SWIG_IsOK(res1)) {
20455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20456 }
20457 {
20458 PyThreadState* __tstate = wxPyBeginAllowThreads();
20459 wxPyArtProvider::Push(arg1);
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 resultobj = SWIG_Py_Void();
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20471 PyObject *resultobj = 0;
20472 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20473 int res1 = 0 ;
20474 PyObject * obj0 = 0 ;
20475 char * kwnames[] = {
20476 (char *) "provider", NULL
20477 };
20478
20479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20480 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20481 if (!SWIG_IsOK(res1)) {
20482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20483 }
20484 {
20485 PyThreadState* __tstate = wxPyBeginAllowThreads();
20486 wxPyArtProvider::Insert(arg1);
20487 wxPyEndAllowThreads(__tstate);
20488 if (PyErr_Occurred()) SWIG_fail;
20489 }
20490 resultobj = SWIG_Py_Void();
20491 return resultobj;
20492 fail:
20493 return NULL;
20494 }
20495
20496
20497 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20498 PyObject *resultobj = 0;
20499 bool result;
20500
20501 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20502 {
20503 PyThreadState* __tstate = wxPyBeginAllowThreads();
20504 result = (bool)wxPyArtProvider::Pop();
20505 wxPyEndAllowThreads(__tstate);
20506 if (PyErr_Occurred()) SWIG_fail;
20507 }
20508 {
20509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20510 }
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20518 PyObject *resultobj = 0;
20519 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20520 bool result;
20521 void *argp1 = 0 ;
20522 int res1 = 0 ;
20523 PyObject * obj0 = 0 ;
20524 char * kwnames[] = {
20525 (char *) "provider", NULL
20526 };
20527
20528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20530 if (!SWIG_IsOK(res1)) {
20531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20532 }
20533 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20534 {
20535 PyThreadState* __tstate = wxPyBeginAllowThreads();
20536 result = (bool)wxPyArtProvider::Delete(arg1);
20537 wxPyEndAllowThreads(__tstate);
20538 if (PyErr_Occurred()) SWIG_fail;
20539 }
20540 {
20541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20542 }
20543 return resultobj;
20544 fail:
20545 return NULL;
20546 }
20547
20548
20549 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20550 PyObject *resultobj = 0;
20551 wxString *arg1 = 0 ;
20552 wxString const &arg2_defvalue = wxPyART_OTHER ;
20553 wxString *arg2 = (wxString *) &arg2_defvalue ;
20554 wxSize const &arg3_defvalue = wxDefaultSize ;
20555 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20556 wxBitmap result;
20557 bool temp1 = false ;
20558 bool temp2 = false ;
20559 wxSize temp3 ;
20560 PyObject * obj0 = 0 ;
20561 PyObject * obj1 = 0 ;
20562 PyObject * obj2 = 0 ;
20563 char * kwnames[] = {
20564 (char *) "id",(char *) "client",(char *) "size", NULL
20565 };
20566
20567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20568 {
20569 arg1 = wxString_in_helper(obj0);
20570 if (arg1 == NULL) SWIG_fail;
20571 temp1 = true;
20572 }
20573 if (obj1) {
20574 {
20575 arg2 = wxString_in_helper(obj1);
20576 if (arg2 == NULL) SWIG_fail;
20577 temp2 = true;
20578 }
20579 }
20580 if (obj2) {
20581 {
20582 arg3 = &temp3;
20583 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20584 }
20585 }
20586 {
20587 if (!wxPyCheckForApp()) SWIG_fail;
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20594 {
20595 if (temp1)
20596 delete arg1;
20597 }
20598 {
20599 if (temp2)
20600 delete arg2;
20601 }
20602 return resultobj;
20603 fail:
20604 {
20605 if (temp1)
20606 delete arg1;
20607 }
20608 {
20609 if (temp2)
20610 delete arg2;
20611 }
20612 return NULL;
20613 }
20614
20615
20616 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20617 PyObject *resultobj = 0;
20618 wxString *arg1 = 0 ;
20619 wxString const &arg2_defvalue = wxPyART_OTHER ;
20620 wxString *arg2 = (wxString *) &arg2_defvalue ;
20621 wxSize const &arg3_defvalue = wxDefaultSize ;
20622 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20623 wxIcon result;
20624 bool temp1 = false ;
20625 bool temp2 = false ;
20626 wxSize temp3 ;
20627 PyObject * obj0 = 0 ;
20628 PyObject * obj1 = 0 ;
20629 PyObject * obj2 = 0 ;
20630 char * kwnames[] = {
20631 (char *) "id",(char *) "client",(char *) "size", NULL
20632 };
20633
20634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20635 {
20636 arg1 = wxString_in_helper(obj0);
20637 if (arg1 == NULL) SWIG_fail;
20638 temp1 = true;
20639 }
20640 if (obj1) {
20641 {
20642 arg2 = wxString_in_helper(obj1);
20643 if (arg2 == NULL) SWIG_fail;
20644 temp2 = true;
20645 }
20646 }
20647 if (obj2) {
20648 {
20649 arg3 = &temp3;
20650 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20651 }
20652 }
20653 {
20654 if (!wxPyCheckForApp()) SWIG_fail;
20655 PyThreadState* __tstate = wxPyBeginAllowThreads();
20656 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20657 wxPyEndAllowThreads(__tstate);
20658 if (PyErr_Occurred()) SWIG_fail;
20659 }
20660 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20661 {
20662 if (temp1)
20663 delete arg1;
20664 }
20665 {
20666 if (temp2)
20667 delete arg2;
20668 }
20669 return resultobj;
20670 fail:
20671 {
20672 if (temp1)
20673 delete arg1;
20674 }
20675 {
20676 if (temp2)
20677 delete arg2;
20678 }
20679 return NULL;
20680 }
20681
20682
20683 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20684 PyObject *resultobj = 0;
20685 wxString *arg1 = 0 ;
20686 bool arg2 = (bool) false ;
20687 wxSize result;
20688 bool temp1 = false ;
20689 bool val2 ;
20690 int ecode2 = 0 ;
20691 PyObject * obj0 = 0 ;
20692 PyObject * obj1 = 0 ;
20693 char * kwnames[] = {
20694 (char *) "client",(char *) "platform_dependent", NULL
20695 };
20696
20697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20698 {
20699 arg1 = wxString_in_helper(obj0);
20700 if (arg1 == NULL) SWIG_fail;
20701 temp1 = true;
20702 }
20703 if (obj1) {
20704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20705 if (!SWIG_IsOK(ecode2)) {
20706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20707 }
20708 arg2 = static_cast< bool >(val2);
20709 }
20710 {
20711 PyThreadState* __tstate = wxPyBeginAllowThreads();
20712 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20717 {
20718 if (temp1)
20719 delete arg1;
20720 }
20721 return resultobj;
20722 fail:
20723 {
20724 if (temp1)
20725 delete arg1;
20726 }
20727 return NULL;
20728 }
20729
20730
20731 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20732 PyObject *resultobj = 0;
20733 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20734 void *argp1 = 0 ;
20735 int res1 = 0 ;
20736 PyObject *swig_obj[1] ;
20737
20738 if (!args) SWIG_fail;
20739 swig_obj[0] = args;
20740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20741 if (!SWIG_IsOK(res1)) {
20742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20743 }
20744 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20745 {
20746 PyThreadState* __tstate = wxPyBeginAllowThreads();
20747 wxPyArtProvider_Destroy(arg1);
20748 wxPyEndAllowThreads(__tstate);
20749 if (PyErr_Occurred()) SWIG_fail;
20750 }
20751 resultobj = SWIG_Py_Void();
20752 return resultobj;
20753 fail:
20754 return NULL;
20755 }
20756
20757
20758 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20759 PyObject *obj;
20760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20761 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20762 return SWIG_Py_Void();
20763 }
20764
20765 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20766 return SWIG_Python_InitShadowInstance(args);
20767 }
20768
20769 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20770 PyObject *resultobj = 0;
20771 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20772 void *argp1 = 0 ;
20773 int res1 = 0 ;
20774 PyObject *swig_obj[1] ;
20775
20776 if (!args) SWIG_fail;
20777 swig_obj[0] = args;
20778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20779 if (!SWIG_IsOK(res1)) {
20780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20781 }
20782 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20783 {
20784 PyThreadState* __tstate = wxPyBeginAllowThreads();
20785 delete arg1;
20786
20787 wxPyEndAllowThreads(__tstate);
20788 if (PyErr_Occurred()) SWIG_fail;
20789 }
20790 resultobj = SWIG_Py_Void();
20791 return resultobj;
20792 fail:
20793 return NULL;
20794 }
20795
20796
20797 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20798 PyObject *resultobj = 0;
20799 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20800 wxConfigBase *result = 0 ;
20801 int res1 = 0 ;
20802 PyObject * obj0 = 0 ;
20803 char * kwnames[] = {
20804 (char *) "config", NULL
20805 };
20806
20807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20808 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20809 if (!SWIG_IsOK(res1)) {
20810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20811 }
20812 {
20813 PyThreadState* __tstate = wxPyBeginAllowThreads();
20814 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20815 wxPyEndAllowThreads(__tstate);
20816 if (PyErr_Occurred()) SWIG_fail;
20817 }
20818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20819 return resultobj;
20820 fail:
20821 return NULL;
20822 }
20823
20824
20825 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20826 PyObject *resultobj = 0;
20827 bool arg1 = (bool) true ;
20828 wxConfigBase *result = 0 ;
20829 bool val1 ;
20830 int ecode1 = 0 ;
20831 PyObject * obj0 = 0 ;
20832 char * kwnames[] = {
20833 (char *) "createOnDemand", NULL
20834 };
20835
20836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20837 if (obj0) {
20838 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20839 if (!SWIG_IsOK(ecode1)) {
20840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20841 }
20842 arg1 = static_cast< bool >(val1);
20843 }
20844 {
20845 PyThreadState* __tstate = wxPyBeginAllowThreads();
20846 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20847 wxPyEndAllowThreads(__tstate);
20848 if (PyErr_Occurred()) SWIG_fail;
20849 }
20850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20851 return resultobj;
20852 fail:
20853 return NULL;
20854 }
20855
20856
20857 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20858 PyObject *resultobj = 0;
20859 wxConfigBase *result = 0 ;
20860
20861 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20862 {
20863 PyThreadState* __tstate = wxPyBeginAllowThreads();
20864 result = (wxConfigBase *)wxConfigBase::Create();
20865 wxPyEndAllowThreads(__tstate);
20866 if (PyErr_Occurred()) SWIG_fail;
20867 }
20868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20869 return resultobj;
20870 fail:
20871 return NULL;
20872 }
20873
20874
20875 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20876 PyObject *resultobj = 0;
20877
20878 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20879 {
20880 PyThreadState* __tstate = wxPyBeginAllowThreads();
20881 wxConfigBase::DontCreateOnDemand();
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 resultobj = SWIG_Py_Void();
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20893 PyObject *resultobj = 0;
20894 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20895 wxString *arg2 = 0 ;
20896 void *argp1 = 0 ;
20897 int res1 = 0 ;
20898 bool temp2 = false ;
20899 PyObject * obj0 = 0 ;
20900 PyObject * obj1 = 0 ;
20901 char * kwnames[] = {
20902 (char *) "self",(char *) "path", NULL
20903 };
20904
20905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20907 if (!SWIG_IsOK(res1)) {
20908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20909 }
20910 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20911 {
20912 arg2 = wxString_in_helper(obj1);
20913 if (arg2 == NULL) SWIG_fail;
20914 temp2 = true;
20915 }
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 (arg1)->SetPath((wxString const &)*arg2);
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = SWIG_Py_Void();
20923 {
20924 if (temp2)
20925 delete arg2;
20926 }
20927 return resultobj;
20928 fail:
20929 {
20930 if (temp2)
20931 delete arg2;
20932 }
20933 return NULL;
20934 }
20935
20936
20937 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20938 PyObject *resultobj = 0;
20939 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20940 wxString *result = 0 ;
20941 void *argp1 = 0 ;
20942 int res1 = 0 ;
20943 PyObject *swig_obj[1] ;
20944
20945 if (!args) SWIG_fail;
20946 swig_obj[0] = args;
20947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20948 if (!SWIG_IsOK(res1)) {
20949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20950 }
20951 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 {
20955 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20956 result = (wxString *) &_result_ref;
20957 }
20958 wxPyEndAllowThreads(__tstate);
20959 if (PyErr_Occurred()) SWIG_fail;
20960 }
20961 {
20962 #if wxUSE_UNICODE
20963 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20964 #else
20965 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20966 #endif
20967 }
20968 return resultobj;
20969 fail:
20970 return NULL;
20971 }
20972
20973
20974 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20975 PyObject *resultobj = 0;
20976 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20977 PyObject *result = 0 ;
20978 void *argp1 = 0 ;
20979 int res1 = 0 ;
20980 PyObject *swig_obj[1] ;
20981
20982 if (!args) SWIG_fail;
20983 swig_obj[0] = args;
20984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20985 if (!SWIG_IsOK(res1)) {
20986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20987 }
20988 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20989 {
20990 PyThreadState* __tstate = wxPyBeginAllowThreads();
20991 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20992 wxPyEndAllowThreads(__tstate);
20993 if (PyErr_Occurred()) SWIG_fail;
20994 }
20995 resultobj = result;
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21003 PyObject *resultobj = 0;
21004 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21005 long arg2 ;
21006 PyObject *result = 0 ;
21007 void *argp1 = 0 ;
21008 int res1 = 0 ;
21009 long val2 ;
21010 int ecode2 = 0 ;
21011 PyObject * obj0 = 0 ;
21012 PyObject * obj1 = 0 ;
21013 char * kwnames[] = {
21014 (char *) "self",(char *) "index", NULL
21015 };
21016
21017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21019 if (!SWIG_IsOK(res1)) {
21020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21021 }
21022 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21023 ecode2 = SWIG_AsVal_long(obj1, &val2);
21024 if (!SWIG_IsOK(ecode2)) {
21025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21026 }
21027 arg2 = static_cast< long >(val2);
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 resultobj = result;
21035 return resultobj;
21036 fail:
21037 return NULL;
21038 }
21039
21040
21041 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21042 PyObject *resultobj = 0;
21043 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21044 PyObject *result = 0 ;
21045 void *argp1 = 0 ;
21046 int res1 = 0 ;
21047 PyObject *swig_obj[1] ;
21048
21049 if (!args) SWIG_fail;
21050 swig_obj[0] = args;
21051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21052 if (!SWIG_IsOK(res1)) {
21053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21054 }
21055 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21056 {
21057 PyThreadState* __tstate = wxPyBeginAllowThreads();
21058 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21059 wxPyEndAllowThreads(__tstate);
21060 if (PyErr_Occurred()) SWIG_fail;
21061 }
21062 resultobj = result;
21063 return resultobj;
21064 fail:
21065 return NULL;
21066 }
21067
21068
21069 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21070 PyObject *resultobj = 0;
21071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21072 long arg2 ;
21073 PyObject *result = 0 ;
21074 void *argp1 = 0 ;
21075 int res1 = 0 ;
21076 long val2 ;
21077 int ecode2 = 0 ;
21078 PyObject * obj0 = 0 ;
21079 PyObject * obj1 = 0 ;
21080 char * kwnames[] = {
21081 (char *) "self",(char *) "index", NULL
21082 };
21083
21084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21086 if (!SWIG_IsOK(res1)) {
21087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21088 }
21089 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21090 ecode2 = SWIG_AsVal_long(obj1, &val2);
21091 if (!SWIG_IsOK(ecode2)) {
21092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21093 }
21094 arg2 = static_cast< long >(val2);
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21098 wxPyEndAllowThreads(__tstate);
21099 if (PyErr_Occurred()) SWIG_fail;
21100 }
21101 resultobj = result;
21102 return resultobj;
21103 fail:
21104 return NULL;
21105 }
21106
21107
21108 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21109 PyObject *resultobj = 0;
21110 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21111 bool arg2 = (bool) false ;
21112 size_t result;
21113 void *argp1 = 0 ;
21114 int res1 = 0 ;
21115 bool val2 ;
21116 int ecode2 = 0 ;
21117 PyObject * obj0 = 0 ;
21118 PyObject * obj1 = 0 ;
21119 char * kwnames[] = {
21120 (char *) "self",(char *) "recursive", NULL
21121 };
21122
21123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21125 if (!SWIG_IsOK(res1)) {
21126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21127 }
21128 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21129 if (obj1) {
21130 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21131 if (!SWIG_IsOK(ecode2)) {
21132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21133 }
21134 arg2 = static_cast< bool >(val2);
21135 }
21136 {
21137 PyThreadState* __tstate = wxPyBeginAllowThreads();
21138 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21139 wxPyEndAllowThreads(__tstate);
21140 if (PyErr_Occurred()) SWIG_fail;
21141 }
21142 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21143 return resultobj;
21144 fail:
21145 return NULL;
21146 }
21147
21148
21149 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21150 PyObject *resultobj = 0;
21151 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21152 bool arg2 = (bool) false ;
21153 size_t result;
21154 void *argp1 = 0 ;
21155 int res1 = 0 ;
21156 bool val2 ;
21157 int ecode2 = 0 ;
21158 PyObject * obj0 = 0 ;
21159 PyObject * obj1 = 0 ;
21160 char * kwnames[] = {
21161 (char *) "self",(char *) "recursive", NULL
21162 };
21163
21164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21166 if (!SWIG_IsOK(res1)) {
21167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21168 }
21169 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21170 if (obj1) {
21171 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21172 if (!SWIG_IsOK(ecode2)) {
21173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21174 }
21175 arg2 = static_cast< bool >(val2);
21176 }
21177 {
21178 PyThreadState* __tstate = wxPyBeginAllowThreads();
21179 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21180 wxPyEndAllowThreads(__tstate);
21181 if (PyErr_Occurred()) SWIG_fail;
21182 }
21183 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21184 return resultobj;
21185 fail:
21186 return NULL;
21187 }
21188
21189
21190 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21191 PyObject *resultobj = 0;
21192 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21193 wxString *arg2 = 0 ;
21194 bool result;
21195 void *argp1 = 0 ;
21196 int res1 = 0 ;
21197 bool temp2 = false ;
21198 PyObject * obj0 = 0 ;
21199 PyObject * obj1 = 0 ;
21200 char * kwnames[] = {
21201 (char *) "self",(char *) "name", NULL
21202 };
21203
21204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21206 if (!SWIG_IsOK(res1)) {
21207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21208 }
21209 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21210 {
21211 arg2 = wxString_in_helper(obj1);
21212 if (arg2 == NULL) SWIG_fail;
21213 temp2 = true;
21214 }
21215 {
21216 PyThreadState* __tstate = wxPyBeginAllowThreads();
21217 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 {
21222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21223 }
21224 {
21225 if (temp2)
21226 delete arg2;
21227 }
21228 return resultobj;
21229 fail:
21230 {
21231 if (temp2)
21232 delete arg2;
21233 }
21234 return NULL;
21235 }
21236
21237
21238 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21239 PyObject *resultobj = 0;
21240 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21241 wxString *arg2 = 0 ;
21242 bool result;
21243 void *argp1 = 0 ;
21244 int res1 = 0 ;
21245 bool temp2 = false ;
21246 PyObject * obj0 = 0 ;
21247 PyObject * obj1 = 0 ;
21248 char * kwnames[] = {
21249 (char *) "self",(char *) "name", NULL
21250 };
21251
21252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21254 if (!SWIG_IsOK(res1)) {
21255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21256 }
21257 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21258 {
21259 arg2 = wxString_in_helper(obj1);
21260 if (arg2 == NULL) SWIG_fail;
21261 temp2 = true;
21262 }
21263 {
21264 PyThreadState* __tstate = wxPyBeginAllowThreads();
21265 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21266 wxPyEndAllowThreads(__tstate);
21267 if (PyErr_Occurred()) SWIG_fail;
21268 }
21269 {
21270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21271 }
21272 {
21273 if (temp2)
21274 delete arg2;
21275 }
21276 return resultobj;
21277 fail:
21278 {
21279 if (temp2)
21280 delete arg2;
21281 }
21282 return NULL;
21283 }
21284
21285
21286 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj = 0;
21288 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21289 wxString *arg2 = 0 ;
21290 bool result;
21291 void *argp1 = 0 ;
21292 int res1 = 0 ;
21293 bool temp2 = false ;
21294 PyObject * obj0 = 0 ;
21295 PyObject * obj1 = 0 ;
21296 char * kwnames[] = {
21297 (char *) "self",(char *) "name", NULL
21298 };
21299
21300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21302 if (!SWIG_IsOK(res1)) {
21303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21304 }
21305 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21306 {
21307 arg2 = wxString_in_helper(obj1);
21308 if (arg2 == NULL) SWIG_fail;
21309 temp2 = true;
21310 }
21311 {
21312 PyThreadState* __tstate = wxPyBeginAllowThreads();
21313 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21314 wxPyEndAllowThreads(__tstate);
21315 if (PyErr_Occurred()) SWIG_fail;
21316 }
21317 {
21318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21319 }
21320 {
21321 if (temp2)
21322 delete arg2;
21323 }
21324 return resultobj;
21325 fail:
21326 {
21327 if (temp2)
21328 delete arg2;
21329 }
21330 return NULL;
21331 }
21332
21333
21334 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21335 PyObject *resultobj = 0;
21336 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21337 wxString *arg2 = 0 ;
21338 wxConfigBase::EntryType result;
21339 void *argp1 = 0 ;
21340 int res1 = 0 ;
21341 bool temp2 = false ;
21342 PyObject * obj0 = 0 ;
21343 PyObject * obj1 = 0 ;
21344 char * kwnames[] = {
21345 (char *) "self",(char *) "name", NULL
21346 };
21347
21348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21350 if (!SWIG_IsOK(res1)) {
21351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21352 }
21353 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21354 {
21355 arg2 = wxString_in_helper(obj1);
21356 if (arg2 == NULL) SWIG_fail;
21357 temp2 = true;
21358 }
21359 {
21360 PyThreadState* __tstate = wxPyBeginAllowThreads();
21361 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21362 wxPyEndAllowThreads(__tstate);
21363 if (PyErr_Occurred()) SWIG_fail;
21364 }
21365 resultobj = SWIG_From_int(static_cast< int >(result));
21366 {
21367 if (temp2)
21368 delete arg2;
21369 }
21370 return resultobj;
21371 fail:
21372 {
21373 if (temp2)
21374 delete arg2;
21375 }
21376 return NULL;
21377 }
21378
21379
21380 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21381 PyObject *resultobj = 0;
21382 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21383 wxString *arg2 = 0 ;
21384 wxString const &arg3_defvalue = wxPyEmptyString ;
21385 wxString *arg3 = (wxString *) &arg3_defvalue ;
21386 wxString result;
21387 void *argp1 = 0 ;
21388 int res1 = 0 ;
21389 bool temp2 = false ;
21390 bool temp3 = false ;
21391 PyObject * obj0 = 0 ;
21392 PyObject * obj1 = 0 ;
21393 PyObject * obj2 = 0 ;
21394 char * kwnames[] = {
21395 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21396 };
21397
21398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21400 if (!SWIG_IsOK(res1)) {
21401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21402 }
21403 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21404 {
21405 arg2 = wxString_in_helper(obj1);
21406 if (arg2 == NULL) SWIG_fail;
21407 temp2 = true;
21408 }
21409 if (obj2) {
21410 {
21411 arg3 = wxString_in_helper(obj2);
21412 if (arg3 == NULL) SWIG_fail;
21413 temp3 = true;
21414 }
21415 }
21416 {
21417 PyThreadState* __tstate = wxPyBeginAllowThreads();
21418 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21419 wxPyEndAllowThreads(__tstate);
21420 if (PyErr_Occurred()) SWIG_fail;
21421 }
21422 {
21423 #if wxUSE_UNICODE
21424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21425 #else
21426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21427 #endif
21428 }
21429 {
21430 if (temp2)
21431 delete arg2;
21432 }
21433 {
21434 if (temp3)
21435 delete arg3;
21436 }
21437 return resultobj;
21438 fail:
21439 {
21440 if (temp2)
21441 delete arg2;
21442 }
21443 {
21444 if (temp3)
21445 delete arg3;
21446 }
21447 return NULL;
21448 }
21449
21450
21451 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21452 PyObject *resultobj = 0;
21453 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21454 wxString *arg2 = 0 ;
21455 long arg3 = (long) 0 ;
21456 long result;
21457 void *argp1 = 0 ;
21458 int res1 = 0 ;
21459 bool temp2 = false ;
21460 long val3 ;
21461 int ecode3 = 0 ;
21462 PyObject * obj0 = 0 ;
21463 PyObject * obj1 = 0 ;
21464 PyObject * obj2 = 0 ;
21465 char * kwnames[] = {
21466 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21467 };
21468
21469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21471 if (!SWIG_IsOK(res1)) {
21472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21473 }
21474 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21475 {
21476 arg2 = wxString_in_helper(obj1);
21477 if (arg2 == NULL) SWIG_fail;
21478 temp2 = true;
21479 }
21480 if (obj2) {
21481 ecode3 = SWIG_AsVal_long(obj2, &val3);
21482 if (!SWIG_IsOK(ecode3)) {
21483 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21484 }
21485 arg3 = static_cast< long >(val3);
21486 }
21487 {
21488 PyThreadState* __tstate = wxPyBeginAllowThreads();
21489 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21490 wxPyEndAllowThreads(__tstate);
21491 if (PyErr_Occurred()) SWIG_fail;
21492 }
21493 resultobj = SWIG_From_long(static_cast< long >(result));
21494 {
21495 if (temp2)
21496 delete arg2;
21497 }
21498 return resultobj;
21499 fail:
21500 {
21501 if (temp2)
21502 delete arg2;
21503 }
21504 return NULL;
21505 }
21506
21507
21508 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21509 PyObject *resultobj = 0;
21510 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21511 wxString *arg2 = 0 ;
21512 double arg3 = (double) 0.0 ;
21513 double result;
21514 void *argp1 = 0 ;
21515 int res1 = 0 ;
21516 bool temp2 = false ;
21517 double val3 ;
21518 int ecode3 = 0 ;
21519 PyObject * obj0 = 0 ;
21520 PyObject * obj1 = 0 ;
21521 PyObject * obj2 = 0 ;
21522 char * kwnames[] = {
21523 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21524 };
21525
21526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21528 if (!SWIG_IsOK(res1)) {
21529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21530 }
21531 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21532 {
21533 arg2 = wxString_in_helper(obj1);
21534 if (arg2 == NULL) SWIG_fail;
21535 temp2 = true;
21536 }
21537 if (obj2) {
21538 ecode3 = SWIG_AsVal_double(obj2, &val3);
21539 if (!SWIG_IsOK(ecode3)) {
21540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21541 }
21542 arg3 = static_cast< double >(val3);
21543 }
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 resultobj = SWIG_From_double(static_cast< double >(result));
21551 {
21552 if (temp2)
21553 delete arg2;
21554 }
21555 return resultobj;
21556 fail:
21557 {
21558 if (temp2)
21559 delete arg2;
21560 }
21561 return NULL;
21562 }
21563
21564
21565 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21566 PyObject *resultobj = 0;
21567 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21568 wxString *arg2 = 0 ;
21569 bool arg3 = (bool) false ;
21570 bool result;
21571 void *argp1 = 0 ;
21572 int res1 = 0 ;
21573 bool temp2 = false ;
21574 bool val3 ;
21575 int ecode3 = 0 ;
21576 PyObject * obj0 = 0 ;
21577 PyObject * obj1 = 0 ;
21578 PyObject * obj2 = 0 ;
21579 char * kwnames[] = {
21580 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21581 };
21582
21583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21585 if (!SWIG_IsOK(res1)) {
21586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21587 }
21588 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21589 {
21590 arg2 = wxString_in_helper(obj1);
21591 if (arg2 == NULL) SWIG_fail;
21592 temp2 = true;
21593 }
21594 if (obj2) {
21595 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21596 if (!SWIG_IsOK(ecode3)) {
21597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21598 }
21599 arg3 = static_cast< bool >(val3);
21600 }
21601 {
21602 PyThreadState* __tstate = wxPyBeginAllowThreads();
21603 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21604 wxPyEndAllowThreads(__tstate);
21605 if (PyErr_Occurred()) SWIG_fail;
21606 }
21607 {
21608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21609 }
21610 {
21611 if (temp2)
21612 delete arg2;
21613 }
21614 return resultobj;
21615 fail:
21616 {
21617 if (temp2)
21618 delete arg2;
21619 }
21620 return NULL;
21621 }
21622
21623
21624 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21625 PyObject *resultobj = 0;
21626 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21627 wxString *arg2 = 0 ;
21628 wxString *arg3 = 0 ;
21629 bool result;
21630 void *argp1 = 0 ;
21631 int res1 = 0 ;
21632 bool temp2 = false ;
21633 bool temp3 = false ;
21634 PyObject * obj0 = 0 ;
21635 PyObject * obj1 = 0 ;
21636 PyObject * obj2 = 0 ;
21637 char * kwnames[] = {
21638 (char *) "self",(char *) "key",(char *) "value", NULL
21639 };
21640
21641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21643 if (!SWIG_IsOK(res1)) {
21644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21645 }
21646 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21647 {
21648 arg2 = wxString_in_helper(obj1);
21649 if (arg2 == NULL) SWIG_fail;
21650 temp2 = true;
21651 }
21652 {
21653 arg3 = wxString_in_helper(obj2);
21654 if (arg3 == NULL) SWIG_fail;
21655 temp3 = true;
21656 }
21657 {
21658 PyThreadState* __tstate = wxPyBeginAllowThreads();
21659 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21660 wxPyEndAllowThreads(__tstate);
21661 if (PyErr_Occurred()) SWIG_fail;
21662 }
21663 {
21664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21665 }
21666 {
21667 if (temp2)
21668 delete arg2;
21669 }
21670 {
21671 if (temp3)
21672 delete arg3;
21673 }
21674 return resultobj;
21675 fail:
21676 {
21677 if (temp2)
21678 delete arg2;
21679 }
21680 {
21681 if (temp3)
21682 delete arg3;
21683 }
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21689 PyObject *resultobj = 0;
21690 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21691 wxString *arg2 = 0 ;
21692 long arg3 ;
21693 bool result;
21694 void *argp1 = 0 ;
21695 int res1 = 0 ;
21696 bool temp2 = false ;
21697 long val3 ;
21698 int ecode3 = 0 ;
21699 PyObject * obj0 = 0 ;
21700 PyObject * obj1 = 0 ;
21701 PyObject * obj2 = 0 ;
21702 char * kwnames[] = {
21703 (char *) "self",(char *) "key",(char *) "value", NULL
21704 };
21705
21706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21708 if (!SWIG_IsOK(res1)) {
21709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21710 }
21711 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21712 {
21713 arg2 = wxString_in_helper(obj1);
21714 if (arg2 == NULL) SWIG_fail;
21715 temp2 = true;
21716 }
21717 ecode3 = SWIG_AsVal_long(obj2, &val3);
21718 if (!SWIG_IsOK(ecode3)) {
21719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21720 }
21721 arg3 = static_cast< long >(val3);
21722 {
21723 PyThreadState* __tstate = wxPyBeginAllowThreads();
21724 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21725 wxPyEndAllowThreads(__tstate);
21726 if (PyErr_Occurred()) SWIG_fail;
21727 }
21728 {
21729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21730 }
21731 {
21732 if (temp2)
21733 delete arg2;
21734 }
21735 return resultobj;
21736 fail:
21737 {
21738 if (temp2)
21739 delete arg2;
21740 }
21741 return NULL;
21742 }
21743
21744
21745 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21746 PyObject *resultobj = 0;
21747 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21748 wxString *arg2 = 0 ;
21749 double arg3 ;
21750 bool result;
21751 void *argp1 = 0 ;
21752 int res1 = 0 ;
21753 bool temp2 = false ;
21754 double val3 ;
21755 int ecode3 = 0 ;
21756 PyObject * obj0 = 0 ;
21757 PyObject * obj1 = 0 ;
21758 PyObject * obj2 = 0 ;
21759 char * kwnames[] = {
21760 (char *) "self",(char *) "key",(char *) "value", NULL
21761 };
21762
21763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21765 if (!SWIG_IsOK(res1)) {
21766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21767 }
21768 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21769 {
21770 arg2 = wxString_in_helper(obj1);
21771 if (arg2 == NULL) SWIG_fail;
21772 temp2 = true;
21773 }
21774 ecode3 = SWIG_AsVal_double(obj2, &val3);
21775 if (!SWIG_IsOK(ecode3)) {
21776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21777 }
21778 arg3 = static_cast< double >(val3);
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21782 wxPyEndAllowThreads(__tstate);
21783 if (PyErr_Occurred()) SWIG_fail;
21784 }
21785 {
21786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21787 }
21788 {
21789 if (temp2)
21790 delete arg2;
21791 }
21792 return resultobj;
21793 fail:
21794 {
21795 if (temp2)
21796 delete arg2;
21797 }
21798 return NULL;
21799 }
21800
21801
21802 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21803 PyObject *resultobj = 0;
21804 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21805 wxString *arg2 = 0 ;
21806 bool arg3 ;
21807 bool result;
21808 void *argp1 = 0 ;
21809 int res1 = 0 ;
21810 bool temp2 = false ;
21811 bool val3 ;
21812 int ecode3 = 0 ;
21813 PyObject * obj0 = 0 ;
21814 PyObject * obj1 = 0 ;
21815 PyObject * obj2 = 0 ;
21816 char * kwnames[] = {
21817 (char *) "self",(char *) "key",(char *) "value", NULL
21818 };
21819
21820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21824 }
21825 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21826 {
21827 arg2 = wxString_in_helper(obj1);
21828 if (arg2 == NULL) SWIG_fail;
21829 temp2 = true;
21830 }
21831 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21832 if (!SWIG_IsOK(ecode3)) {
21833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21834 }
21835 arg3 = static_cast< bool >(val3);
21836 {
21837 PyThreadState* __tstate = wxPyBeginAllowThreads();
21838 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21839 wxPyEndAllowThreads(__tstate);
21840 if (PyErr_Occurred()) SWIG_fail;
21841 }
21842 {
21843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21844 }
21845 {
21846 if (temp2)
21847 delete arg2;
21848 }
21849 return resultobj;
21850 fail:
21851 {
21852 if (temp2)
21853 delete arg2;
21854 }
21855 return NULL;
21856 }
21857
21858
21859 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21860 PyObject *resultobj = 0;
21861 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21862 bool arg2 = (bool) false ;
21863 bool result;
21864 void *argp1 = 0 ;
21865 int res1 = 0 ;
21866 bool val2 ;
21867 int ecode2 = 0 ;
21868 PyObject * obj0 = 0 ;
21869 PyObject * obj1 = 0 ;
21870 char * kwnames[] = {
21871 (char *) "self",(char *) "currentOnly", NULL
21872 };
21873
21874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21876 if (!SWIG_IsOK(res1)) {
21877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21878 }
21879 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21880 if (obj1) {
21881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21882 if (!SWIG_IsOK(ecode2)) {
21883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21884 }
21885 arg2 = static_cast< bool >(val2);
21886 }
21887 {
21888 PyThreadState* __tstate = wxPyBeginAllowThreads();
21889 result = (bool)(arg1)->Flush(arg2);
21890 wxPyEndAllowThreads(__tstate);
21891 if (PyErr_Occurred()) SWIG_fail;
21892 }
21893 {
21894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21895 }
21896 return resultobj;
21897 fail:
21898 return NULL;
21899 }
21900
21901
21902 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21903 PyObject *resultobj = 0;
21904 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21905 wxString *arg2 = 0 ;
21906 wxString *arg3 = 0 ;
21907 bool result;
21908 void *argp1 = 0 ;
21909 int res1 = 0 ;
21910 bool temp2 = false ;
21911 bool temp3 = false ;
21912 PyObject * obj0 = 0 ;
21913 PyObject * obj1 = 0 ;
21914 PyObject * obj2 = 0 ;
21915 char * kwnames[] = {
21916 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21917 };
21918
21919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21921 if (!SWIG_IsOK(res1)) {
21922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21923 }
21924 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21925 {
21926 arg2 = wxString_in_helper(obj1);
21927 if (arg2 == NULL) SWIG_fail;
21928 temp2 = true;
21929 }
21930 {
21931 arg3 = wxString_in_helper(obj2);
21932 if (arg3 == NULL) SWIG_fail;
21933 temp3 = true;
21934 }
21935 {
21936 PyThreadState* __tstate = wxPyBeginAllowThreads();
21937 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 {
21942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21943 }
21944 {
21945 if (temp2)
21946 delete arg2;
21947 }
21948 {
21949 if (temp3)
21950 delete arg3;
21951 }
21952 return resultobj;
21953 fail:
21954 {
21955 if (temp2)
21956 delete arg2;
21957 }
21958 {
21959 if (temp3)
21960 delete arg3;
21961 }
21962 return NULL;
21963 }
21964
21965
21966 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21967 PyObject *resultobj = 0;
21968 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21969 wxString *arg2 = 0 ;
21970 wxString *arg3 = 0 ;
21971 bool result;
21972 void *argp1 = 0 ;
21973 int res1 = 0 ;
21974 bool temp2 = false ;
21975 bool temp3 = false ;
21976 PyObject * obj0 = 0 ;
21977 PyObject * obj1 = 0 ;
21978 PyObject * obj2 = 0 ;
21979 char * kwnames[] = {
21980 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21981 };
21982
21983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21985 if (!SWIG_IsOK(res1)) {
21986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21987 }
21988 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21989 {
21990 arg2 = wxString_in_helper(obj1);
21991 if (arg2 == NULL) SWIG_fail;
21992 temp2 = true;
21993 }
21994 {
21995 arg3 = wxString_in_helper(obj2);
21996 if (arg3 == NULL) SWIG_fail;
21997 temp3 = true;
21998 }
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 {
22006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22007 }
22008 {
22009 if (temp2)
22010 delete arg2;
22011 }
22012 {
22013 if (temp3)
22014 delete arg3;
22015 }
22016 return resultobj;
22017 fail:
22018 {
22019 if (temp2)
22020 delete arg2;
22021 }
22022 {
22023 if (temp3)
22024 delete arg3;
22025 }
22026 return NULL;
22027 }
22028
22029
22030 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22031 PyObject *resultobj = 0;
22032 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22033 wxString *arg2 = 0 ;
22034 bool arg3 = (bool) true ;
22035 bool result;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 bool temp2 = false ;
22039 bool val3 ;
22040 int ecode3 = 0 ;
22041 PyObject * obj0 = 0 ;
22042 PyObject * obj1 = 0 ;
22043 PyObject * obj2 = 0 ;
22044 char * kwnames[] = {
22045 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22046 };
22047
22048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22050 if (!SWIG_IsOK(res1)) {
22051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22052 }
22053 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22054 {
22055 arg2 = wxString_in_helper(obj1);
22056 if (arg2 == NULL) SWIG_fail;
22057 temp2 = true;
22058 }
22059 if (obj2) {
22060 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22061 if (!SWIG_IsOK(ecode3)) {
22062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22063 }
22064 arg3 = static_cast< bool >(val3);
22065 }
22066 {
22067 PyThreadState* __tstate = wxPyBeginAllowThreads();
22068 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22069 wxPyEndAllowThreads(__tstate);
22070 if (PyErr_Occurred()) SWIG_fail;
22071 }
22072 {
22073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22074 }
22075 {
22076 if (temp2)
22077 delete arg2;
22078 }
22079 return resultobj;
22080 fail:
22081 {
22082 if (temp2)
22083 delete arg2;
22084 }
22085 return NULL;
22086 }
22087
22088
22089 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22090 PyObject *resultobj = 0;
22091 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22092 wxString *arg2 = 0 ;
22093 bool result;
22094 void *argp1 = 0 ;
22095 int res1 = 0 ;
22096 bool temp2 = false ;
22097 PyObject * obj0 = 0 ;
22098 PyObject * obj1 = 0 ;
22099 char * kwnames[] = {
22100 (char *) "self",(char *) "key", NULL
22101 };
22102
22103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22105 if (!SWIG_IsOK(res1)) {
22106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22107 }
22108 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22109 {
22110 arg2 = wxString_in_helper(obj1);
22111 if (arg2 == NULL) SWIG_fail;
22112 temp2 = true;
22113 }
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 {
22121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22122 }
22123 {
22124 if (temp2)
22125 delete arg2;
22126 }
22127 return resultobj;
22128 fail:
22129 {
22130 if (temp2)
22131 delete arg2;
22132 }
22133 return NULL;
22134 }
22135
22136
22137 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22138 PyObject *resultobj = 0;
22139 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22140 bool result;
22141 void *argp1 = 0 ;
22142 int res1 = 0 ;
22143 PyObject *swig_obj[1] ;
22144
22145 if (!args) SWIG_fail;
22146 swig_obj[0] = args;
22147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22148 if (!SWIG_IsOK(res1)) {
22149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22150 }
22151 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 result = (bool)(arg1)->DeleteAll();
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 {
22159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22160 }
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj = 0;
22169 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22170 bool arg2 = (bool) true ;
22171 void *argp1 = 0 ;
22172 int res1 = 0 ;
22173 bool val2 ;
22174 int ecode2 = 0 ;
22175 PyObject * obj0 = 0 ;
22176 PyObject * obj1 = 0 ;
22177 char * kwnames[] = {
22178 (char *) "self",(char *) "doIt", NULL
22179 };
22180
22181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22183 if (!SWIG_IsOK(res1)) {
22184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22185 }
22186 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22187 if (obj1) {
22188 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22189 if (!SWIG_IsOK(ecode2)) {
22190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22191 }
22192 arg2 = static_cast< bool >(val2);
22193 }
22194 {
22195 PyThreadState* __tstate = wxPyBeginAllowThreads();
22196 (arg1)->SetExpandEnvVars(arg2);
22197 wxPyEndAllowThreads(__tstate);
22198 if (PyErr_Occurred()) SWIG_fail;
22199 }
22200 resultobj = SWIG_Py_Void();
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22208 PyObject *resultobj = 0;
22209 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22210 bool result;
22211 void *argp1 = 0 ;
22212 int res1 = 0 ;
22213 PyObject *swig_obj[1] ;
22214
22215 if (!args) SWIG_fail;
22216 swig_obj[0] = args;
22217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22218 if (!SWIG_IsOK(res1)) {
22219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22220 }
22221 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 {
22229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22230 }
22231 return resultobj;
22232 fail:
22233 return NULL;
22234 }
22235
22236
22237 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22238 PyObject *resultobj = 0;
22239 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22240 bool arg2 = (bool) true ;
22241 void *argp1 = 0 ;
22242 int res1 = 0 ;
22243 bool val2 ;
22244 int ecode2 = 0 ;
22245 PyObject * obj0 = 0 ;
22246 PyObject * obj1 = 0 ;
22247 char * kwnames[] = {
22248 (char *) "self",(char *) "doIt", NULL
22249 };
22250
22251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22253 if (!SWIG_IsOK(res1)) {
22254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22255 }
22256 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22257 if (obj1) {
22258 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22259 if (!SWIG_IsOK(ecode2)) {
22260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22261 }
22262 arg2 = static_cast< bool >(val2);
22263 }
22264 {
22265 PyThreadState* __tstate = wxPyBeginAllowThreads();
22266 (arg1)->SetRecordDefaults(arg2);
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 resultobj = SWIG_Py_Void();
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22278 PyObject *resultobj = 0;
22279 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22280 bool result;
22281 void *argp1 = 0 ;
22282 int res1 = 0 ;
22283 PyObject *swig_obj[1] ;
22284
22285 if (!args) SWIG_fail;
22286 swig_obj[0] = args;
22287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22288 if (!SWIG_IsOK(res1)) {
22289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22290 }
22291 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22292 {
22293 PyThreadState* __tstate = wxPyBeginAllowThreads();
22294 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 {
22299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22300 }
22301 return resultobj;
22302 fail:
22303 return NULL;
22304 }
22305
22306
22307 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22308 PyObject *resultobj = 0;
22309 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22310 wxString *arg2 = 0 ;
22311 wxString result;
22312 void *argp1 = 0 ;
22313 int res1 = 0 ;
22314 bool temp2 = false ;
22315 PyObject * obj0 = 0 ;
22316 PyObject * obj1 = 0 ;
22317 char * kwnames[] = {
22318 (char *) "self",(char *) "str", NULL
22319 };
22320
22321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22323 if (!SWIG_IsOK(res1)) {
22324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22325 }
22326 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22327 {
22328 arg2 = wxString_in_helper(obj1);
22329 if (arg2 == NULL) SWIG_fail;
22330 temp2 = true;
22331 }
22332 {
22333 PyThreadState* __tstate = wxPyBeginAllowThreads();
22334 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22335 wxPyEndAllowThreads(__tstate);
22336 if (PyErr_Occurred()) SWIG_fail;
22337 }
22338 {
22339 #if wxUSE_UNICODE
22340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22341 #else
22342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22343 #endif
22344 }
22345 {
22346 if (temp2)
22347 delete arg2;
22348 }
22349 return resultobj;
22350 fail:
22351 {
22352 if (temp2)
22353 delete arg2;
22354 }
22355 return NULL;
22356 }
22357
22358
22359 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22360 PyObject *resultobj = 0;
22361 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22362 wxString result;
22363 void *argp1 = 0 ;
22364 int res1 = 0 ;
22365 PyObject *swig_obj[1] ;
22366
22367 if (!args) SWIG_fail;
22368 swig_obj[0] = args;
22369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22370 if (!SWIG_IsOK(res1)) {
22371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22372 }
22373 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 result = ((wxConfigBase const *)arg1)->GetAppName();
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 {
22381 #if wxUSE_UNICODE
22382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22383 #else
22384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22385 #endif
22386 }
22387 return resultobj;
22388 fail:
22389 return NULL;
22390 }
22391
22392
22393 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22394 PyObject *resultobj = 0;
22395 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22396 wxString result;
22397 void *argp1 = 0 ;
22398 int res1 = 0 ;
22399 PyObject *swig_obj[1] ;
22400
22401 if (!args) SWIG_fail;
22402 swig_obj[0] = args;
22403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22404 if (!SWIG_IsOK(res1)) {
22405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22406 }
22407 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 result = ((wxConfigBase const *)arg1)->GetVendorName();
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 {
22415 #if wxUSE_UNICODE
22416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22417 #else
22418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22419 #endif
22420 }
22421 return resultobj;
22422 fail:
22423 return NULL;
22424 }
22425
22426
22427 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22428 PyObject *resultobj = 0;
22429 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22430 wxString *arg2 = 0 ;
22431 void *argp1 = 0 ;
22432 int res1 = 0 ;
22433 bool temp2 = false ;
22434 PyObject * obj0 = 0 ;
22435 PyObject * obj1 = 0 ;
22436 char * kwnames[] = {
22437 (char *) "self",(char *) "appName", NULL
22438 };
22439
22440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22442 if (!SWIG_IsOK(res1)) {
22443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22444 }
22445 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22446 {
22447 arg2 = wxString_in_helper(obj1);
22448 if (arg2 == NULL) SWIG_fail;
22449 temp2 = true;
22450 }
22451 {
22452 PyThreadState* __tstate = wxPyBeginAllowThreads();
22453 (arg1)->SetAppName((wxString const &)*arg2);
22454 wxPyEndAllowThreads(__tstate);
22455 if (PyErr_Occurred()) SWIG_fail;
22456 }
22457 resultobj = SWIG_Py_Void();
22458 {
22459 if (temp2)
22460 delete arg2;
22461 }
22462 return resultobj;
22463 fail:
22464 {
22465 if (temp2)
22466 delete arg2;
22467 }
22468 return NULL;
22469 }
22470
22471
22472 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22473 PyObject *resultobj = 0;
22474 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22475 wxString *arg2 = 0 ;
22476 void *argp1 = 0 ;
22477 int res1 = 0 ;
22478 bool temp2 = false ;
22479 PyObject * obj0 = 0 ;
22480 PyObject * obj1 = 0 ;
22481 char * kwnames[] = {
22482 (char *) "self",(char *) "vendorName", NULL
22483 };
22484
22485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22487 if (!SWIG_IsOK(res1)) {
22488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22489 }
22490 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22491 {
22492 arg2 = wxString_in_helper(obj1);
22493 if (arg2 == NULL) SWIG_fail;
22494 temp2 = true;
22495 }
22496 {
22497 PyThreadState* __tstate = wxPyBeginAllowThreads();
22498 (arg1)->SetVendorName((wxString const &)*arg2);
22499 wxPyEndAllowThreads(__tstate);
22500 if (PyErr_Occurred()) SWIG_fail;
22501 }
22502 resultobj = SWIG_Py_Void();
22503 {
22504 if (temp2)
22505 delete arg2;
22506 }
22507 return resultobj;
22508 fail:
22509 {
22510 if (temp2)
22511 delete arg2;
22512 }
22513 return NULL;
22514 }
22515
22516
22517 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22518 PyObject *resultobj = 0;
22519 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22520 long arg2 ;
22521 void *argp1 = 0 ;
22522 int res1 = 0 ;
22523 long val2 ;
22524 int ecode2 = 0 ;
22525 PyObject * obj0 = 0 ;
22526 PyObject * obj1 = 0 ;
22527 char * kwnames[] = {
22528 (char *) "self",(char *) "style", NULL
22529 };
22530
22531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22533 if (!SWIG_IsOK(res1)) {
22534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22535 }
22536 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22537 ecode2 = SWIG_AsVal_long(obj1, &val2);
22538 if (!SWIG_IsOK(ecode2)) {
22539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22540 }
22541 arg2 = static_cast< long >(val2);
22542 {
22543 PyThreadState* __tstate = wxPyBeginAllowThreads();
22544 (arg1)->SetStyle(arg2);
22545 wxPyEndAllowThreads(__tstate);
22546 if (PyErr_Occurred()) SWIG_fail;
22547 }
22548 resultobj = SWIG_Py_Void();
22549 return resultobj;
22550 fail:
22551 return NULL;
22552 }
22553
22554
22555 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22556 PyObject *resultobj = 0;
22557 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22558 long result;
22559 void *argp1 = 0 ;
22560 int res1 = 0 ;
22561 PyObject *swig_obj[1] ;
22562
22563 if (!args) SWIG_fail;
22564 swig_obj[0] = args;
22565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22566 if (!SWIG_IsOK(res1)) {
22567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22568 }
22569 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22570 {
22571 PyThreadState* __tstate = wxPyBeginAllowThreads();
22572 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22573 wxPyEndAllowThreads(__tstate);
22574 if (PyErr_Occurred()) SWIG_fail;
22575 }
22576 resultobj = SWIG_From_long(static_cast< long >(result));
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22584 PyObject *obj;
22585 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22586 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22587 return SWIG_Py_Void();
22588 }
22589
22590 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22591 PyObject *resultobj = 0;
22592 wxString const &arg1_defvalue = wxPyEmptyString ;
22593 wxString *arg1 = (wxString *) &arg1_defvalue ;
22594 wxString const &arg2_defvalue = wxPyEmptyString ;
22595 wxString *arg2 = (wxString *) &arg2_defvalue ;
22596 wxString const &arg3_defvalue = wxPyEmptyString ;
22597 wxString *arg3 = (wxString *) &arg3_defvalue ;
22598 wxString const &arg4_defvalue = wxPyEmptyString ;
22599 wxString *arg4 = (wxString *) &arg4_defvalue ;
22600 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22601 wxConfig *result = 0 ;
22602 bool temp1 = false ;
22603 bool temp2 = false ;
22604 bool temp3 = false ;
22605 bool temp4 = false ;
22606 long val5 ;
22607 int ecode5 = 0 ;
22608 PyObject * obj0 = 0 ;
22609 PyObject * obj1 = 0 ;
22610 PyObject * obj2 = 0 ;
22611 PyObject * obj3 = 0 ;
22612 PyObject * obj4 = 0 ;
22613 char * kwnames[] = {
22614 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22615 };
22616
22617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22618 if (obj0) {
22619 {
22620 arg1 = wxString_in_helper(obj0);
22621 if (arg1 == NULL) SWIG_fail;
22622 temp1 = true;
22623 }
22624 }
22625 if (obj1) {
22626 {
22627 arg2 = wxString_in_helper(obj1);
22628 if (arg2 == NULL) SWIG_fail;
22629 temp2 = true;
22630 }
22631 }
22632 if (obj2) {
22633 {
22634 arg3 = wxString_in_helper(obj2);
22635 if (arg3 == NULL) SWIG_fail;
22636 temp3 = true;
22637 }
22638 }
22639 if (obj3) {
22640 {
22641 arg4 = wxString_in_helper(obj3);
22642 if (arg4 == NULL) SWIG_fail;
22643 temp4 = true;
22644 }
22645 }
22646 if (obj4) {
22647 ecode5 = SWIG_AsVal_long(obj4, &val5);
22648 if (!SWIG_IsOK(ecode5)) {
22649 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22650 }
22651 arg5 = static_cast< long >(val5);
22652 }
22653 {
22654 PyThreadState* __tstate = wxPyBeginAllowThreads();
22655 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22656 wxPyEndAllowThreads(__tstate);
22657 if (PyErr_Occurred()) SWIG_fail;
22658 }
22659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22660 {
22661 if (temp1)
22662 delete arg1;
22663 }
22664 {
22665 if (temp2)
22666 delete arg2;
22667 }
22668 {
22669 if (temp3)
22670 delete arg3;
22671 }
22672 {
22673 if (temp4)
22674 delete arg4;
22675 }
22676 return resultobj;
22677 fail:
22678 {
22679 if (temp1)
22680 delete arg1;
22681 }
22682 {
22683 if (temp2)
22684 delete arg2;
22685 }
22686 {
22687 if (temp3)
22688 delete arg3;
22689 }
22690 {
22691 if (temp4)
22692 delete arg4;
22693 }
22694 return NULL;
22695 }
22696
22697
22698 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22699 PyObject *resultobj = 0;
22700 wxConfig *arg1 = (wxConfig *) 0 ;
22701 void *argp1 = 0 ;
22702 int res1 = 0 ;
22703 PyObject *swig_obj[1] ;
22704
22705 if (!args) SWIG_fail;
22706 swig_obj[0] = args;
22707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22708 if (!SWIG_IsOK(res1)) {
22709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22710 }
22711 arg1 = reinterpret_cast< wxConfig * >(argp1);
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 delete arg1;
22715
22716 wxPyEndAllowThreads(__tstate);
22717 if (PyErr_Occurred()) SWIG_fail;
22718 }
22719 resultobj = SWIG_Py_Void();
22720 return resultobj;
22721 fail:
22722 return NULL;
22723 }
22724
22725
22726 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22727 PyObject *obj;
22728 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22729 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22730 return SWIG_Py_Void();
22731 }
22732
22733 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22734 return SWIG_Python_InitShadowInstance(args);
22735 }
22736
22737 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22738 PyObject *resultobj = 0;
22739 wxString const &arg1_defvalue = wxPyEmptyString ;
22740 wxString *arg1 = (wxString *) &arg1_defvalue ;
22741 wxString const &arg2_defvalue = wxPyEmptyString ;
22742 wxString *arg2 = (wxString *) &arg2_defvalue ;
22743 wxString const &arg3_defvalue = wxPyEmptyString ;
22744 wxString *arg3 = (wxString *) &arg3_defvalue ;
22745 wxString const &arg4_defvalue = wxPyEmptyString ;
22746 wxString *arg4 = (wxString *) &arg4_defvalue ;
22747 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22748 wxFileConfig *result = 0 ;
22749 bool temp1 = false ;
22750 bool temp2 = false ;
22751 bool temp3 = false ;
22752 bool temp4 = false ;
22753 long val5 ;
22754 int ecode5 = 0 ;
22755 PyObject * obj0 = 0 ;
22756 PyObject * obj1 = 0 ;
22757 PyObject * obj2 = 0 ;
22758 PyObject * obj3 = 0 ;
22759 PyObject * obj4 = 0 ;
22760 char * kwnames[] = {
22761 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22762 };
22763
22764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22765 if (obj0) {
22766 {
22767 arg1 = wxString_in_helper(obj0);
22768 if (arg1 == NULL) SWIG_fail;
22769 temp1 = true;
22770 }
22771 }
22772 if (obj1) {
22773 {
22774 arg2 = wxString_in_helper(obj1);
22775 if (arg2 == NULL) SWIG_fail;
22776 temp2 = true;
22777 }
22778 }
22779 if (obj2) {
22780 {
22781 arg3 = wxString_in_helper(obj2);
22782 if (arg3 == NULL) SWIG_fail;
22783 temp3 = true;
22784 }
22785 }
22786 if (obj3) {
22787 {
22788 arg4 = wxString_in_helper(obj3);
22789 if (arg4 == NULL) SWIG_fail;
22790 temp4 = true;
22791 }
22792 }
22793 if (obj4) {
22794 ecode5 = SWIG_AsVal_long(obj4, &val5);
22795 if (!SWIG_IsOK(ecode5)) {
22796 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22797 }
22798 arg5 = static_cast< long >(val5);
22799 }
22800 {
22801 PyThreadState* __tstate = wxPyBeginAllowThreads();
22802 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22803 wxPyEndAllowThreads(__tstate);
22804 if (PyErr_Occurred()) SWIG_fail;
22805 }
22806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22807 {
22808 if (temp1)
22809 delete arg1;
22810 }
22811 {
22812 if (temp2)
22813 delete arg2;
22814 }
22815 {
22816 if (temp3)
22817 delete arg3;
22818 }
22819 {
22820 if (temp4)
22821 delete arg4;
22822 }
22823 return resultobj;
22824 fail:
22825 {
22826 if (temp1)
22827 delete arg1;
22828 }
22829 {
22830 if (temp2)
22831 delete arg2;
22832 }
22833 {
22834 if (temp3)
22835 delete arg3;
22836 }
22837 {
22838 if (temp4)
22839 delete arg4;
22840 }
22841 return NULL;
22842 }
22843
22844
22845 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22846 PyObject *resultobj = 0;
22847 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22848 void *argp1 = 0 ;
22849 int res1 = 0 ;
22850 PyObject *swig_obj[1] ;
22851
22852 if (!args) SWIG_fail;
22853 swig_obj[0] = args;
22854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22855 if (!SWIG_IsOK(res1)) {
22856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22857 }
22858 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22859 {
22860 PyThreadState* __tstate = wxPyBeginAllowThreads();
22861 delete arg1;
22862
22863 wxPyEndAllowThreads(__tstate);
22864 if (PyErr_Occurred()) SWIG_fail;
22865 }
22866 resultobj = SWIG_Py_Void();
22867 return resultobj;
22868 fail:
22869 return NULL;
22870 }
22871
22872
22873 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22874 PyObject *obj;
22875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22876 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22877 return SWIG_Py_Void();
22878 }
22879
22880 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22881 return SWIG_Python_InitShadowInstance(args);
22882 }
22883
22884 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22885 PyObject *resultobj = 0;
22886 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22887 wxString *arg2 = 0 ;
22888 wxConfigPathChanger *result = 0 ;
22889 void *argp1 = 0 ;
22890 int res1 = 0 ;
22891 bool temp2 = false ;
22892 PyObject * obj0 = 0 ;
22893 PyObject * obj1 = 0 ;
22894 char * kwnames[] = {
22895 (char *) "config",(char *) "entry", NULL
22896 };
22897
22898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22902 }
22903 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22904 {
22905 arg2 = wxString_in_helper(obj1);
22906 if (arg2 == NULL) SWIG_fail;
22907 temp2 = true;
22908 }
22909 {
22910 PyThreadState* __tstate = wxPyBeginAllowThreads();
22911 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22912 wxPyEndAllowThreads(__tstate);
22913 if (PyErr_Occurred()) SWIG_fail;
22914 }
22915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22916 {
22917 if (temp2)
22918 delete arg2;
22919 }
22920 return resultobj;
22921 fail:
22922 {
22923 if (temp2)
22924 delete arg2;
22925 }
22926 return NULL;
22927 }
22928
22929
22930 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22931 PyObject *resultobj = 0;
22932 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22933 void *argp1 = 0 ;
22934 int res1 = 0 ;
22935 PyObject *swig_obj[1] ;
22936
22937 if (!args) SWIG_fail;
22938 swig_obj[0] = args;
22939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22940 if (!SWIG_IsOK(res1)) {
22941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22942 }
22943 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22944 {
22945 PyThreadState* __tstate = wxPyBeginAllowThreads();
22946 delete arg1;
22947
22948 wxPyEndAllowThreads(__tstate);
22949 if (PyErr_Occurred()) SWIG_fail;
22950 }
22951 resultobj = SWIG_Py_Void();
22952 return resultobj;
22953 fail:
22954 return NULL;
22955 }
22956
22957
22958 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22959 PyObject *resultobj = 0;
22960 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22961 wxString *result = 0 ;
22962 void *argp1 = 0 ;
22963 int res1 = 0 ;
22964 PyObject *swig_obj[1] ;
22965
22966 if (!args) SWIG_fail;
22967 swig_obj[0] = args;
22968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22971 }
22972 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22973 {
22974 PyThreadState* __tstate = wxPyBeginAllowThreads();
22975 {
22976 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22977 result = (wxString *) &_result_ref;
22978 }
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 {
22983 #if wxUSE_UNICODE
22984 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22985 #else
22986 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22987 #endif
22988 }
22989 return resultobj;
22990 fail:
22991 return NULL;
22992 }
22993
22994
22995 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22996 PyObject *obj;
22997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22998 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22999 return SWIG_Py_Void();
23000 }
23001
23002 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23003 return SWIG_Python_InitShadowInstance(args);
23004 }
23005
23006 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23007 PyObject *resultobj = 0;
23008 wxString *arg1 = 0 ;
23009 wxString result;
23010 bool temp1 = false ;
23011 PyObject * obj0 = 0 ;
23012 char * kwnames[] = {
23013 (char *) "sz", NULL
23014 };
23015
23016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23017 {
23018 arg1 = wxString_in_helper(obj0);
23019 if (arg1 == NULL) SWIG_fail;
23020 temp1 = true;
23021 }
23022 {
23023 PyThreadState* __tstate = wxPyBeginAllowThreads();
23024 result = wxExpandEnvVars((wxString const &)*arg1);
23025 wxPyEndAllowThreads(__tstate);
23026 if (PyErr_Occurred()) SWIG_fail;
23027 }
23028 {
23029 #if wxUSE_UNICODE
23030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23031 #else
23032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23033 #endif
23034 }
23035 {
23036 if (temp1)
23037 delete arg1;
23038 }
23039 return resultobj;
23040 fail:
23041 {
23042 if (temp1)
23043 delete arg1;
23044 }
23045 return NULL;
23046 }
23047
23048
23049 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23050 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23051 return 1;
23052 }
23053
23054
23055 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23056 PyObject *pyobj = 0;
23057
23058 {
23059 #if wxUSE_UNICODE
23060 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23061 #else
23062 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23063 #endif
23064 }
23065 return pyobj;
23066 }
23067
23068
23069 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23070 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23071 return 1;
23072 }
23073
23074
23075 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23076 PyObject *pyobj = 0;
23077
23078 {
23079 #if wxUSE_UNICODE
23080 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23081 #else
23082 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23083 #endif
23084 }
23085 return pyobj;
23086 }
23087
23088
23089 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23090 PyObject *resultobj = 0;
23091 wxDateTime::Country arg1 ;
23092 int val1 ;
23093 int ecode1 = 0 ;
23094 PyObject * obj0 = 0 ;
23095 char * kwnames[] = {
23096 (char *) "country", NULL
23097 };
23098
23099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23100 ecode1 = SWIG_AsVal_int(obj0, &val1);
23101 if (!SWIG_IsOK(ecode1)) {
23102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23103 }
23104 arg1 = static_cast< wxDateTime::Country >(val1);
23105 {
23106 PyThreadState* __tstate = wxPyBeginAllowThreads();
23107 wxDateTime::SetCountry(arg1);
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 resultobj = SWIG_Py_Void();
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23119 PyObject *resultobj = 0;
23120 wxDateTime::Country result;
23121
23122 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 result = (wxDateTime::Country)wxDateTime::GetCountry();
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 resultobj = SWIG_From_int(static_cast< int >(result));
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23137 PyObject *resultobj = 0;
23138 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23139 bool result;
23140 int val1 ;
23141 int ecode1 = 0 ;
23142 PyObject * obj0 = 0 ;
23143 char * kwnames[] = {
23144 (char *) "country", NULL
23145 };
23146
23147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23148 if (obj0) {
23149 ecode1 = SWIG_AsVal_int(obj0, &val1);
23150 if (!SWIG_IsOK(ecode1)) {
23151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23152 }
23153 arg1 = static_cast< wxDateTime::Country >(val1);
23154 }
23155 {
23156 PyThreadState* __tstate = wxPyBeginAllowThreads();
23157 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23158 wxPyEndAllowThreads(__tstate);
23159 if (PyErr_Occurred()) SWIG_fail;
23160 }
23161 {
23162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23163 }
23164 return resultobj;
23165 fail:
23166 return NULL;
23167 }
23168
23169
23170 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23171 PyObject *resultobj = 0;
23172 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23173 int result;
23174 int val1 ;
23175 int ecode1 = 0 ;
23176 PyObject * obj0 = 0 ;
23177 char * kwnames[] = {
23178 (char *) "cal", NULL
23179 };
23180
23181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23182 if (obj0) {
23183 ecode1 = SWIG_AsVal_int(obj0, &val1);
23184 if (!SWIG_IsOK(ecode1)) {
23185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23186 }
23187 arg1 = static_cast< wxDateTime::Calendar >(val1);
23188 }
23189 {
23190 PyThreadState* __tstate = wxPyBeginAllowThreads();
23191 result = (int)wxDateTime::GetCurrentYear(arg1);
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 resultobj = SWIG_From_int(static_cast< int >(result));
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23203 PyObject *resultobj = 0;
23204 int arg1 ;
23205 int result;
23206 int val1 ;
23207 int ecode1 = 0 ;
23208 PyObject * obj0 = 0 ;
23209 char * kwnames[] = {
23210 (char *) "year", NULL
23211 };
23212
23213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23214 ecode1 = SWIG_AsVal_int(obj0, &val1);
23215 if (!SWIG_IsOK(ecode1)) {
23216 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23217 }
23218 arg1 = static_cast< int >(val1);
23219 {
23220 PyThreadState* __tstate = wxPyBeginAllowThreads();
23221 result = (int)wxDateTime::ConvertYearToBC(arg1);
23222 wxPyEndAllowThreads(__tstate);
23223 if (PyErr_Occurred()) SWIG_fail;
23224 }
23225 resultobj = SWIG_From_int(static_cast< int >(result));
23226 return resultobj;
23227 fail:
23228 return NULL;
23229 }
23230
23231
23232 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23233 PyObject *resultobj = 0;
23234 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23235 wxDateTime::Month result;
23236 int val1 ;
23237 int ecode1 = 0 ;
23238 PyObject * obj0 = 0 ;
23239 char * kwnames[] = {
23240 (char *) "cal", NULL
23241 };
23242
23243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23244 if (obj0) {
23245 ecode1 = SWIG_AsVal_int(obj0, &val1);
23246 if (!SWIG_IsOK(ecode1)) {
23247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23248 }
23249 arg1 = static_cast< wxDateTime::Calendar >(val1);
23250 }
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23254 wxPyEndAllowThreads(__tstate);
23255 if (PyErr_Occurred()) SWIG_fail;
23256 }
23257 resultobj = SWIG_From_int(static_cast< int >(result));
23258 return resultobj;
23259 fail:
23260 return NULL;
23261 }
23262
23263
23264 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23265 PyObject *resultobj = 0;
23266 int arg1 = (int) wxDateTime::Inv_Year ;
23267 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23268 bool result;
23269 int val1 ;
23270 int ecode1 = 0 ;
23271 int val2 ;
23272 int ecode2 = 0 ;
23273 PyObject * obj0 = 0 ;
23274 PyObject * obj1 = 0 ;
23275 char * kwnames[] = {
23276 (char *) "year",(char *) "cal", NULL
23277 };
23278
23279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23280 if (obj0) {
23281 ecode1 = SWIG_AsVal_int(obj0, &val1);
23282 if (!SWIG_IsOK(ecode1)) {
23283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23284 }
23285 arg1 = static_cast< int >(val1);
23286 }
23287 if (obj1) {
23288 ecode2 = SWIG_AsVal_int(obj1, &val2);
23289 if (!SWIG_IsOK(ecode2)) {
23290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23291 }
23292 arg2 = static_cast< wxDateTime::Calendar >(val2);
23293 }
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23297 wxPyEndAllowThreads(__tstate);
23298 if (PyErr_Occurred()) SWIG_fail;
23299 }
23300 {
23301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23302 }
23303 return resultobj;
23304 fail:
23305 return NULL;
23306 }
23307
23308
23309 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23310 PyObject *resultobj = 0;
23311 int arg1 = (int) wxDateTime::Inv_Year ;
23312 int result;
23313 int val1 ;
23314 int ecode1 = 0 ;
23315 PyObject * obj0 = 0 ;
23316 char * kwnames[] = {
23317 (char *) "year", NULL
23318 };
23319
23320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23321 if (obj0) {
23322 ecode1 = SWIG_AsVal_int(obj0, &val1);
23323 if (!SWIG_IsOK(ecode1)) {
23324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23325 }
23326 arg1 = static_cast< int >(val1);
23327 }
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 result = (int)wxDateTime::GetCentury(arg1);
23331 wxPyEndAllowThreads(__tstate);
23332 if (PyErr_Occurred()) SWIG_fail;
23333 }
23334 resultobj = SWIG_From_int(static_cast< int >(result));
23335 return resultobj;
23336 fail:
23337 return NULL;
23338 }
23339
23340
23341 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23342 PyObject *resultobj = 0;
23343 int arg1 ;
23344 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23345 int result;
23346 int val1 ;
23347 int ecode1 = 0 ;
23348 int val2 ;
23349 int ecode2 = 0 ;
23350 PyObject * obj0 = 0 ;
23351 PyObject * obj1 = 0 ;
23352 char * kwnames[] = {
23353 (char *) "year",(char *) "cal", NULL
23354 };
23355
23356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23357 ecode1 = SWIG_AsVal_int(obj0, &val1);
23358 if (!SWIG_IsOK(ecode1)) {
23359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23360 }
23361 arg1 = static_cast< int >(val1);
23362 if (obj1) {
23363 ecode2 = SWIG_AsVal_int(obj1, &val2);
23364 if (!SWIG_IsOK(ecode2)) {
23365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23366 }
23367 arg2 = static_cast< wxDateTime::Calendar >(val2);
23368 }
23369 {
23370 PyThreadState* __tstate = wxPyBeginAllowThreads();
23371 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 resultobj = SWIG_From_int(static_cast< int >(result));
23376 return resultobj;
23377 fail:
23378 return NULL;
23379 }
23380
23381
23382 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23383 PyObject *resultobj = 0;
23384 wxDateTime::Month arg1 ;
23385 int arg2 = (int) wxDateTime::Inv_Year ;
23386 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23387 int result;
23388 int val1 ;
23389 int ecode1 = 0 ;
23390 int val2 ;
23391 int ecode2 = 0 ;
23392 int val3 ;
23393 int ecode3 = 0 ;
23394 PyObject * obj0 = 0 ;
23395 PyObject * obj1 = 0 ;
23396 PyObject * obj2 = 0 ;
23397 char * kwnames[] = {
23398 (char *) "month",(char *) "year",(char *) "cal", NULL
23399 };
23400
23401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23402 ecode1 = SWIG_AsVal_int(obj0, &val1);
23403 if (!SWIG_IsOK(ecode1)) {
23404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23405 }
23406 arg1 = static_cast< wxDateTime::Month >(val1);
23407 if (obj1) {
23408 ecode2 = SWIG_AsVal_int(obj1, &val2);
23409 if (!SWIG_IsOK(ecode2)) {
23410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23411 }
23412 arg2 = static_cast< int >(val2);
23413 }
23414 if (obj2) {
23415 ecode3 = SWIG_AsVal_int(obj2, &val3);
23416 if (!SWIG_IsOK(ecode3)) {
23417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23418 }
23419 arg3 = static_cast< wxDateTime::Calendar >(val3);
23420 }
23421 {
23422 PyThreadState* __tstate = wxPyBeginAllowThreads();
23423 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 resultobj = SWIG_From_int(static_cast< int >(result));
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23435 PyObject *resultobj = 0;
23436 wxDateTime::Month arg1 ;
23437 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23438 wxString result;
23439 int val1 ;
23440 int ecode1 = 0 ;
23441 int val2 ;
23442 int ecode2 = 0 ;
23443 PyObject * obj0 = 0 ;
23444 PyObject * obj1 = 0 ;
23445 char * kwnames[] = {
23446 (char *) "month",(char *) "flags", NULL
23447 };
23448
23449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23450 ecode1 = SWIG_AsVal_int(obj0, &val1);
23451 if (!SWIG_IsOK(ecode1)) {
23452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23453 }
23454 arg1 = static_cast< wxDateTime::Month >(val1);
23455 if (obj1) {
23456 ecode2 = SWIG_AsVal_int(obj1, &val2);
23457 if (!SWIG_IsOK(ecode2)) {
23458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23459 }
23460 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23461 }
23462 {
23463 PyThreadState* __tstate = wxPyBeginAllowThreads();
23464 result = wxDateTime::GetMonthName(arg1,arg2);
23465 wxPyEndAllowThreads(__tstate);
23466 if (PyErr_Occurred()) SWIG_fail;
23467 }
23468 {
23469 #if wxUSE_UNICODE
23470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23471 #else
23472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23473 #endif
23474 }
23475 return resultobj;
23476 fail:
23477 return NULL;
23478 }
23479
23480
23481 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23482 PyObject *resultobj = 0;
23483 wxDateTime::WeekDay arg1 ;
23484 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23485 wxString result;
23486 int val1 ;
23487 int ecode1 = 0 ;
23488 int val2 ;
23489 int ecode2 = 0 ;
23490 PyObject * obj0 = 0 ;
23491 PyObject * obj1 = 0 ;
23492 char * kwnames[] = {
23493 (char *) "weekday",(char *) "flags", NULL
23494 };
23495
23496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23497 ecode1 = SWIG_AsVal_int(obj0, &val1);
23498 if (!SWIG_IsOK(ecode1)) {
23499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23500 }
23501 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23502 if (obj1) {
23503 ecode2 = SWIG_AsVal_int(obj1, &val2);
23504 if (!SWIG_IsOK(ecode2)) {
23505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23506 }
23507 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23508 }
23509 {
23510 PyThreadState* __tstate = wxPyBeginAllowThreads();
23511 result = wxDateTime::GetWeekDayName(arg1,arg2);
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 {
23516 #if wxUSE_UNICODE
23517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23518 #else
23519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23520 #endif
23521 }
23522 return resultobj;
23523 fail:
23524 return NULL;
23525 }
23526
23527
23528 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23529 PyObject *resultobj = 0;
23530 PyObject *result = 0 ;
23531
23532 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23533 {
23534 PyThreadState* __tstate = wxPyBeginAllowThreads();
23535 result = (PyObject *)wxDateTime_GetAmPmStrings();
23536 wxPyEndAllowThreads(__tstate);
23537 if (PyErr_Occurred()) SWIG_fail;
23538 }
23539 resultobj = result;
23540 return resultobj;
23541 fail:
23542 return NULL;
23543 }
23544
23545
23546 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj = 0;
23548 int arg1 = (int) wxDateTime::Inv_Year ;
23549 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23550 bool result;
23551 int val1 ;
23552 int ecode1 = 0 ;
23553 int val2 ;
23554 int ecode2 = 0 ;
23555 PyObject * obj0 = 0 ;
23556 PyObject * obj1 = 0 ;
23557 char * kwnames[] = {
23558 (char *) "year",(char *) "country", NULL
23559 };
23560
23561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23562 if (obj0) {
23563 ecode1 = SWIG_AsVal_int(obj0, &val1);
23564 if (!SWIG_IsOK(ecode1)) {
23565 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23566 }
23567 arg1 = static_cast< int >(val1);
23568 }
23569 if (obj1) {
23570 ecode2 = SWIG_AsVal_int(obj1, &val2);
23571 if (!SWIG_IsOK(ecode2)) {
23572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23573 }
23574 arg2 = static_cast< wxDateTime::Country >(val2);
23575 }
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 {
23583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23584 }
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23592 PyObject *resultobj = 0;
23593 int arg1 = (int) wxDateTime::Inv_Year ;
23594 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23595 wxDateTime result;
23596 int val1 ;
23597 int ecode1 = 0 ;
23598 int val2 ;
23599 int ecode2 = 0 ;
23600 PyObject * obj0 = 0 ;
23601 PyObject * obj1 = 0 ;
23602 char * kwnames[] = {
23603 (char *) "year",(char *) "country", NULL
23604 };
23605
23606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23607 if (obj0) {
23608 ecode1 = SWIG_AsVal_int(obj0, &val1);
23609 if (!SWIG_IsOK(ecode1)) {
23610 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23611 }
23612 arg1 = static_cast< int >(val1);
23613 }
23614 if (obj1) {
23615 ecode2 = SWIG_AsVal_int(obj1, &val2);
23616 if (!SWIG_IsOK(ecode2)) {
23617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23618 }
23619 arg2 = static_cast< wxDateTime::Country >(val2);
23620 }
23621 {
23622 PyThreadState* __tstate = wxPyBeginAllowThreads();
23623 result = wxDateTime::GetBeginDST(arg1,arg2);
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23628 return resultobj;
23629 fail:
23630 return NULL;
23631 }
23632
23633
23634 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23635 PyObject *resultobj = 0;
23636 int arg1 = (int) wxDateTime::Inv_Year ;
23637 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23638 wxDateTime result;
23639 int val1 ;
23640 int ecode1 = 0 ;
23641 int val2 ;
23642 int ecode2 = 0 ;
23643 PyObject * obj0 = 0 ;
23644 PyObject * obj1 = 0 ;
23645 char * kwnames[] = {
23646 (char *) "year",(char *) "country", NULL
23647 };
23648
23649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23650 if (obj0) {
23651 ecode1 = SWIG_AsVal_int(obj0, &val1);
23652 if (!SWIG_IsOK(ecode1)) {
23653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23654 }
23655 arg1 = static_cast< int >(val1);
23656 }
23657 if (obj1) {
23658 ecode2 = SWIG_AsVal_int(obj1, &val2);
23659 if (!SWIG_IsOK(ecode2)) {
23660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23661 }
23662 arg2 = static_cast< wxDateTime::Country >(val2);
23663 }
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 result = wxDateTime::GetEndDST(arg1,arg2);
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 PyObject *resultobj = 0;
23679 wxDateTime result;
23680
23681 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23682 {
23683 PyThreadState* __tstate = wxPyBeginAllowThreads();
23684 result = wxDateTime::Now();
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23696 PyObject *resultobj = 0;
23697 wxDateTime result;
23698
23699 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23700 {
23701 PyThreadState* __tstate = wxPyBeginAllowThreads();
23702 result = wxDateTime::UNow();
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23707 return resultobj;
23708 fail:
23709 return NULL;
23710 }
23711
23712
23713 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23714 PyObject *resultobj = 0;
23715 wxDateTime result;
23716
23717 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 result = wxDateTime::Today();
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23732 PyObject *resultobj = 0;
23733 wxDateTime *result = 0 ;
23734
23735 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23736 {
23737 PyThreadState* __tstate = wxPyBeginAllowThreads();
23738 result = (wxDateTime *)new wxDateTime();
23739 wxPyEndAllowThreads(__tstate);
23740 if (PyErr_Occurred()) SWIG_fail;
23741 }
23742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23743 return resultobj;
23744 fail:
23745 return NULL;
23746 }
23747
23748
23749 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23750 PyObject *resultobj = 0;
23751 time_t arg1 ;
23752 wxDateTime *result = 0 ;
23753 unsigned int val1 ;
23754 int ecode1 = 0 ;
23755 PyObject * obj0 = 0 ;
23756 char * kwnames[] = {
23757 (char *) "timet", NULL
23758 };
23759
23760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23761 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23762 if (!SWIG_IsOK(ecode1)) {
23763 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23764 }
23765 arg1 = static_cast< time_t >(val1);
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = (wxDateTime *)new wxDateTime(arg1);
23769 wxPyEndAllowThreads(__tstate);
23770 if (PyErr_Occurred()) SWIG_fail;
23771 }
23772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23773 return resultobj;
23774 fail:
23775 return NULL;
23776 }
23777
23778
23779 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23780 PyObject *resultobj = 0;
23781 double arg1 ;
23782 wxDateTime *result = 0 ;
23783 double val1 ;
23784 int ecode1 = 0 ;
23785 PyObject * obj0 = 0 ;
23786 char * kwnames[] = {
23787 (char *) "jdn", NULL
23788 };
23789
23790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23791 ecode1 = SWIG_AsVal_double(obj0, &val1);
23792 if (!SWIG_IsOK(ecode1)) {
23793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23794 }
23795 arg1 = static_cast< double >(val1);
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 result = (wxDateTime *)new wxDateTime(arg1);
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23810 PyObject *resultobj = 0;
23811 int arg1 ;
23812 int arg2 = (int) 0 ;
23813 int arg3 = (int) 0 ;
23814 int arg4 = (int) 0 ;
23815 wxDateTime *result = 0 ;
23816 int val1 ;
23817 int ecode1 = 0 ;
23818 int val2 ;
23819 int ecode2 = 0 ;
23820 int val3 ;
23821 int ecode3 = 0 ;
23822 int val4 ;
23823 int ecode4 = 0 ;
23824 PyObject * obj0 = 0 ;
23825 PyObject * obj1 = 0 ;
23826 PyObject * obj2 = 0 ;
23827 PyObject * obj3 = 0 ;
23828 char * kwnames[] = {
23829 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23830 };
23831
23832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23833 ecode1 = SWIG_AsVal_int(obj0, &val1);
23834 if (!SWIG_IsOK(ecode1)) {
23835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23836 }
23837 arg1 = static_cast< int >(val1);
23838 if (obj1) {
23839 ecode2 = SWIG_AsVal_int(obj1, &val2);
23840 if (!SWIG_IsOK(ecode2)) {
23841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23842 }
23843 arg2 = static_cast< int >(val2);
23844 }
23845 if (obj2) {
23846 ecode3 = SWIG_AsVal_int(obj2, &val3);
23847 if (!SWIG_IsOK(ecode3)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23849 }
23850 arg3 = static_cast< int >(val3);
23851 }
23852 if (obj3) {
23853 ecode4 = SWIG_AsVal_int(obj3, &val4);
23854 if (!SWIG_IsOK(ecode4)) {
23855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23856 }
23857 arg4 = static_cast< int >(val4);
23858 }
23859 {
23860 PyThreadState* __tstate = wxPyBeginAllowThreads();
23861 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23862 wxPyEndAllowThreads(__tstate);
23863 if (PyErr_Occurred()) SWIG_fail;
23864 }
23865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23866 return resultobj;
23867 fail:
23868 return NULL;
23869 }
23870
23871
23872 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23873 PyObject *resultobj = 0;
23874 int arg1 ;
23875 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23876 int arg3 = (int) wxDateTime::Inv_Year ;
23877 int arg4 = (int) 0 ;
23878 int arg5 = (int) 0 ;
23879 int arg6 = (int) 0 ;
23880 int arg7 = (int) 0 ;
23881 wxDateTime *result = 0 ;
23882 int val1 ;
23883 int ecode1 = 0 ;
23884 int val2 ;
23885 int ecode2 = 0 ;
23886 int val3 ;
23887 int ecode3 = 0 ;
23888 int val4 ;
23889 int ecode4 = 0 ;
23890 int val5 ;
23891 int ecode5 = 0 ;
23892 int val6 ;
23893 int ecode6 = 0 ;
23894 int val7 ;
23895 int ecode7 = 0 ;
23896 PyObject * obj0 = 0 ;
23897 PyObject * obj1 = 0 ;
23898 PyObject * obj2 = 0 ;
23899 PyObject * obj3 = 0 ;
23900 PyObject * obj4 = 0 ;
23901 PyObject * obj5 = 0 ;
23902 PyObject * obj6 = 0 ;
23903 char * kwnames[] = {
23904 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23905 };
23906
23907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23908 ecode1 = SWIG_AsVal_int(obj0, &val1);
23909 if (!SWIG_IsOK(ecode1)) {
23910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23911 }
23912 arg1 = static_cast< int >(val1);
23913 if (obj1) {
23914 ecode2 = SWIG_AsVal_int(obj1, &val2);
23915 if (!SWIG_IsOK(ecode2)) {
23916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23917 }
23918 arg2 = static_cast< wxDateTime::Month >(val2);
23919 }
23920 if (obj2) {
23921 ecode3 = SWIG_AsVal_int(obj2, &val3);
23922 if (!SWIG_IsOK(ecode3)) {
23923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23924 }
23925 arg3 = static_cast< int >(val3);
23926 }
23927 if (obj3) {
23928 ecode4 = SWIG_AsVal_int(obj3, &val4);
23929 if (!SWIG_IsOK(ecode4)) {
23930 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23931 }
23932 arg4 = static_cast< int >(val4);
23933 }
23934 if (obj4) {
23935 ecode5 = SWIG_AsVal_int(obj4, &val5);
23936 if (!SWIG_IsOK(ecode5)) {
23937 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23938 }
23939 arg5 = static_cast< int >(val5);
23940 }
23941 if (obj5) {
23942 ecode6 = SWIG_AsVal_int(obj5, &val6);
23943 if (!SWIG_IsOK(ecode6)) {
23944 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23945 }
23946 arg6 = static_cast< int >(val6);
23947 }
23948 if (obj6) {
23949 ecode7 = SWIG_AsVal_int(obj6, &val7);
23950 if (!SWIG_IsOK(ecode7)) {
23951 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23952 }
23953 arg7 = static_cast< int >(val7);
23954 }
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj = 0;
23970 wxDateTime *arg1 = 0 ;
23971 wxDateTime *result = 0 ;
23972 void *argp1 = 0 ;
23973 int res1 = 0 ;
23974 PyObject * obj0 = 0 ;
23975 char * kwnames[] = {
23976 (char *) "date", NULL
23977 };
23978
23979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23980 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23981 if (!SWIG_IsOK(res1)) {
23982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23983 }
23984 if (!argp1) {
23985 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23986 }
23987 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23988 {
23989 PyThreadState* __tstate = wxPyBeginAllowThreads();
23990 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23991 wxPyEndAllowThreads(__tstate);
23992 if (PyErr_Occurred()) SWIG_fail;
23993 }
23994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23995 return resultobj;
23996 fail:
23997 return NULL;
23998 }
23999
24000
24001 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24002 PyObject *resultobj = 0;
24003 wxDateTime *arg1 = (wxDateTime *) 0 ;
24004 void *argp1 = 0 ;
24005 int res1 = 0 ;
24006 PyObject *swig_obj[1] ;
24007
24008 if (!args) SWIG_fail;
24009 swig_obj[0] = args;
24010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24011 if (!SWIG_IsOK(res1)) {
24012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24013 }
24014 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24015 {
24016 PyThreadState* __tstate = wxPyBeginAllowThreads();
24017 delete arg1;
24018
24019 wxPyEndAllowThreads(__tstate);
24020 if (PyErr_Occurred()) SWIG_fail;
24021 }
24022 resultobj = SWIG_Py_Void();
24023 return resultobj;
24024 fail:
24025 return NULL;
24026 }
24027
24028
24029 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24030 PyObject *resultobj = 0;
24031 wxDateTime *arg1 = (wxDateTime *) 0 ;
24032 wxDateTime *result = 0 ;
24033 void *argp1 = 0 ;
24034 int res1 = 0 ;
24035 PyObject *swig_obj[1] ;
24036
24037 if (!args) SWIG_fail;
24038 swig_obj[0] = args;
24039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24040 if (!SWIG_IsOK(res1)) {
24041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24042 }
24043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24044 {
24045 PyThreadState* __tstate = wxPyBeginAllowThreads();
24046 {
24047 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24048 result = (wxDateTime *) &_result_ref;
24049 }
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj = 0;
24062 wxDateTime *arg1 = (wxDateTime *) 0 ;
24063 time_t arg2 ;
24064 wxDateTime *result = 0 ;
24065 void *argp1 = 0 ;
24066 int res1 = 0 ;
24067 unsigned int val2 ;
24068 int ecode2 = 0 ;
24069 PyObject * obj0 = 0 ;
24070 PyObject * obj1 = 0 ;
24071 char * kwnames[] = {
24072 (char *) "self",(char *) "timet", NULL
24073 };
24074
24075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24077 if (!SWIG_IsOK(res1)) {
24078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24079 }
24080 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24081 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24082 if (!SWIG_IsOK(ecode2)) {
24083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24084 }
24085 arg2 = static_cast< time_t >(val2);
24086 {
24087 PyThreadState* __tstate = wxPyBeginAllowThreads();
24088 {
24089 wxDateTime &_result_ref = (arg1)->Set(arg2);
24090 result = (wxDateTime *) &_result_ref;
24091 }
24092 wxPyEndAllowThreads(__tstate);
24093 if (PyErr_Occurred()) SWIG_fail;
24094 }
24095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24096 return resultobj;
24097 fail:
24098 return NULL;
24099 }
24100
24101
24102 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24103 PyObject *resultobj = 0;
24104 wxDateTime *arg1 = (wxDateTime *) 0 ;
24105 double arg2 ;
24106 wxDateTime *result = 0 ;
24107 void *argp1 = 0 ;
24108 int res1 = 0 ;
24109 double val2 ;
24110 int ecode2 = 0 ;
24111 PyObject * obj0 = 0 ;
24112 PyObject * obj1 = 0 ;
24113 char * kwnames[] = {
24114 (char *) "self",(char *) "jdn", NULL
24115 };
24116
24117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24119 if (!SWIG_IsOK(res1)) {
24120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24121 }
24122 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24123 ecode2 = SWIG_AsVal_double(obj1, &val2);
24124 if (!SWIG_IsOK(ecode2)) {
24125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24126 }
24127 arg2 = static_cast< double >(val2);
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 {
24131 wxDateTime &_result_ref = (arg1)->Set(arg2);
24132 result = (wxDateTime *) &_result_ref;
24133 }
24134 wxPyEndAllowThreads(__tstate);
24135 if (PyErr_Occurred()) SWIG_fail;
24136 }
24137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24145 PyObject *resultobj = 0;
24146 wxDateTime *arg1 = (wxDateTime *) 0 ;
24147 int arg2 ;
24148 int arg3 = (int) 0 ;
24149 int arg4 = (int) 0 ;
24150 int arg5 = (int) 0 ;
24151 wxDateTime *result = 0 ;
24152 void *argp1 = 0 ;
24153 int res1 = 0 ;
24154 int val2 ;
24155 int ecode2 = 0 ;
24156 int val3 ;
24157 int ecode3 = 0 ;
24158 int val4 ;
24159 int ecode4 = 0 ;
24160 int val5 ;
24161 int ecode5 = 0 ;
24162 PyObject * obj0 = 0 ;
24163 PyObject * obj1 = 0 ;
24164 PyObject * obj2 = 0 ;
24165 PyObject * obj3 = 0 ;
24166 PyObject * obj4 = 0 ;
24167 char * kwnames[] = {
24168 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24169 };
24170
24171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24173 if (!SWIG_IsOK(res1)) {
24174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24175 }
24176 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24177 ecode2 = SWIG_AsVal_int(obj1, &val2);
24178 if (!SWIG_IsOK(ecode2)) {
24179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24180 }
24181 arg2 = static_cast< int >(val2);
24182 if (obj2) {
24183 ecode3 = SWIG_AsVal_int(obj2, &val3);
24184 if (!SWIG_IsOK(ecode3)) {
24185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24186 }
24187 arg3 = static_cast< int >(val3);
24188 }
24189 if (obj3) {
24190 ecode4 = SWIG_AsVal_int(obj3, &val4);
24191 if (!SWIG_IsOK(ecode4)) {
24192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24193 }
24194 arg4 = static_cast< int >(val4);
24195 }
24196 if (obj4) {
24197 ecode5 = SWIG_AsVal_int(obj4, &val5);
24198 if (!SWIG_IsOK(ecode5)) {
24199 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24200 }
24201 arg5 = static_cast< int >(val5);
24202 }
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 {
24206 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24207 result = (wxDateTime *) &_result_ref;
24208 }
24209 wxPyEndAllowThreads(__tstate);
24210 if (PyErr_Occurred()) SWIG_fail;
24211 }
24212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24213 return resultobj;
24214 fail:
24215 return NULL;
24216 }
24217
24218
24219 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24220 PyObject *resultobj = 0;
24221 wxDateTime *arg1 = (wxDateTime *) 0 ;
24222 int arg2 ;
24223 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24224 int arg4 = (int) wxDateTime::Inv_Year ;
24225 int arg5 = (int) 0 ;
24226 int arg6 = (int) 0 ;
24227 int arg7 = (int) 0 ;
24228 int arg8 = (int) 0 ;
24229 wxDateTime *result = 0 ;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 int val2 ;
24233 int ecode2 = 0 ;
24234 int val3 ;
24235 int ecode3 = 0 ;
24236 int val4 ;
24237 int ecode4 = 0 ;
24238 int val5 ;
24239 int ecode5 = 0 ;
24240 int val6 ;
24241 int ecode6 = 0 ;
24242 int val7 ;
24243 int ecode7 = 0 ;
24244 int val8 ;
24245 int ecode8 = 0 ;
24246 PyObject * obj0 = 0 ;
24247 PyObject * obj1 = 0 ;
24248 PyObject * obj2 = 0 ;
24249 PyObject * obj3 = 0 ;
24250 PyObject * obj4 = 0 ;
24251 PyObject * obj5 = 0 ;
24252 PyObject * obj6 = 0 ;
24253 PyObject * obj7 = 0 ;
24254 char * kwnames[] = {
24255 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24256 };
24257
24258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24260 if (!SWIG_IsOK(res1)) {
24261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24262 }
24263 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24264 ecode2 = SWIG_AsVal_int(obj1, &val2);
24265 if (!SWIG_IsOK(ecode2)) {
24266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24267 }
24268 arg2 = static_cast< int >(val2);
24269 if (obj2) {
24270 ecode3 = SWIG_AsVal_int(obj2, &val3);
24271 if (!SWIG_IsOK(ecode3)) {
24272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24273 }
24274 arg3 = static_cast< wxDateTime::Month >(val3);
24275 }
24276 if (obj3) {
24277 ecode4 = SWIG_AsVal_int(obj3, &val4);
24278 if (!SWIG_IsOK(ecode4)) {
24279 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24280 }
24281 arg4 = static_cast< int >(val4);
24282 }
24283 if (obj4) {
24284 ecode5 = SWIG_AsVal_int(obj4, &val5);
24285 if (!SWIG_IsOK(ecode5)) {
24286 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24287 }
24288 arg5 = static_cast< int >(val5);
24289 }
24290 if (obj5) {
24291 ecode6 = SWIG_AsVal_int(obj5, &val6);
24292 if (!SWIG_IsOK(ecode6)) {
24293 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24294 }
24295 arg6 = static_cast< int >(val6);
24296 }
24297 if (obj6) {
24298 ecode7 = SWIG_AsVal_int(obj6, &val7);
24299 if (!SWIG_IsOK(ecode7)) {
24300 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24301 }
24302 arg7 = static_cast< int >(val7);
24303 }
24304 if (obj7) {
24305 ecode8 = SWIG_AsVal_int(obj7, &val8);
24306 if (!SWIG_IsOK(ecode8)) {
24307 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24308 }
24309 arg8 = static_cast< int >(val8);
24310 }
24311 {
24312 PyThreadState* __tstate = wxPyBeginAllowThreads();
24313 {
24314 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24315 result = (wxDateTime *) &_result_ref;
24316 }
24317 wxPyEndAllowThreads(__tstate);
24318 if (PyErr_Occurred()) SWIG_fail;
24319 }
24320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24321 return resultobj;
24322 fail:
24323 return NULL;
24324 }
24325
24326
24327 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24328 PyObject *resultobj = 0;
24329 wxDateTime *arg1 = (wxDateTime *) 0 ;
24330 wxDateTime *result = 0 ;
24331 void *argp1 = 0 ;
24332 int res1 = 0 ;
24333 PyObject *swig_obj[1] ;
24334
24335 if (!args) SWIG_fail;
24336 swig_obj[0] = args;
24337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24338 if (!SWIG_IsOK(res1)) {
24339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24340 }
24341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 {
24345 wxDateTime &_result_ref = (arg1)->ResetTime();
24346 result = (wxDateTime *) &_result_ref;
24347 }
24348 wxPyEndAllowThreads(__tstate);
24349 if (PyErr_Occurred()) SWIG_fail;
24350 }
24351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj = 0;
24360 wxDateTime *arg1 = (wxDateTime *) 0 ;
24361 int arg2 ;
24362 wxDateTime *result = 0 ;
24363 void *argp1 = 0 ;
24364 int res1 = 0 ;
24365 int val2 ;
24366 int ecode2 = 0 ;
24367 PyObject * obj0 = 0 ;
24368 PyObject * obj1 = 0 ;
24369 char * kwnames[] = {
24370 (char *) "self",(char *) "year", NULL
24371 };
24372
24373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24377 }
24378 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24379 ecode2 = SWIG_AsVal_int(obj1, &val2);
24380 if (!SWIG_IsOK(ecode2)) {
24381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24382 }
24383 arg2 = static_cast< int >(val2);
24384 {
24385 PyThreadState* __tstate = wxPyBeginAllowThreads();
24386 {
24387 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24388 result = (wxDateTime *) &_result_ref;
24389 }
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24394 return resultobj;
24395 fail:
24396 return NULL;
24397 }
24398
24399
24400 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj = 0;
24402 wxDateTime *arg1 = (wxDateTime *) 0 ;
24403 wxDateTime::Month arg2 ;
24404 wxDateTime *result = 0 ;
24405 void *argp1 = 0 ;
24406 int res1 = 0 ;
24407 int val2 ;
24408 int ecode2 = 0 ;
24409 PyObject * obj0 = 0 ;
24410 PyObject * obj1 = 0 ;
24411 char * kwnames[] = {
24412 (char *) "self",(char *) "month", NULL
24413 };
24414
24415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24417 if (!SWIG_IsOK(res1)) {
24418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24419 }
24420 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24421 ecode2 = SWIG_AsVal_int(obj1, &val2);
24422 if (!SWIG_IsOK(ecode2)) {
24423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24424 }
24425 arg2 = static_cast< wxDateTime::Month >(val2);
24426 {
24427 PyThreadState* __tstate = wxPyBeginAllowThreads();
24428 {
24429 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24430 result = (wxDateTime *) &_result_ref;
24431 }
24432 wxPyEndAllowThreads(__tstate);
24433 if (PyErr_Occurred()) SWIG_fail;
24434 }
24435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24436 return resultobj;
24437 fail:
24438 return NULL;
24439 }
24440
24441
24442 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24443 PyObject *resultobj = 0;
24444 wxDateTime *arg1 = (wxDateTime *) 0 ;
24445 int arg2 ;
24446 wxDateTime *result = 0 ;
24447 void *argp1 = 0 ;
24448 int res1 = 0 ;
24449 int val2 ;
24450 int ecode2 = 0 ;
24451 PyObject * obj0 = 0 ;
24452 PyObject * obj1 = 0 ;
24453 char * kwnames[] = {
24454 (char *) "self",(char *) "day", NULL
24455 };
24456
24457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24459 if (!SWIG_IsOK(res1)) {
24460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24461 }
24462 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24463 ecode2 = SWIG_AsVal_int(obj1, &val2);
24464 if (!SWIG_IsOK(ecode2)) {
24465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24466 }
24467 arg2 = static_cast< int >(val2);
24468 {
24469 PyThreadState* __tstate = wxPyBeginAllowThreads();
24470 {
24471 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24472 result = (wxDateTime *) &_result_ref;
24473 }
24474 wxPyEndAllowThreads(__tstate);
24475 if (PyErr_Occurred()) SWIG_fail;
24476 }
24477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24478 return resultobj;
24479 fail:
24480 return NULL;
24481 }
24482
24483
24484 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj = 0;
24486 wxDateTime *arg1 = (wxDateTime *) 0 ;
24487 int arg2 ;
24488 wxDateTime *result = 0 ;
24489 void *argp1 = 0 ;
24490 int res1 = 0 ;
24491 int val2 ;
24492 int ecode2 = 0 ;
24493 PyObject * obj0 = 0 ;
24494 PyObject * obj1 = 0 ;
24495 char * kwnames[] = {
24496 (char *) "self",(char *) "hour", NULL
24497 };
24498
24499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) 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_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24503 }
24504 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24505 ecode2 = SWIG_AsVal_int(obj1, &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24508 }
24509 arg2 = static_cast< int >(val2);
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 {
24513 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24514 result = (wxDateTime *) &_result_ref;
24515 }
24516 wxPyEndAllowThreads(__tstate);
24517 if (PyErr_Occurred()) SWIG_fail;
24518 }
24519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24520 return resultobj;
24521 fail:
24522 return NULL;
24523 }
24524
24525
24526 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24527 PyObject *resultobj = 0;
24528 wxDateTime *arg1 = (wxDateTime *) 0 ;
24529 int arg2 ;
24530 wxDateTime *result = 0 ;
24531 void *argp1 = 0 ;
24532 int res1 = 0 ;
24533 int val2 ;
24534 int ecode2 = 0 ;
24535 PyObject * obj0 = 0 ;
24536 PyObject * obj1 = 0 ;
24537 char * kwnames[] = {
24538 (char *) "self",(char *) "minute", NULL
24539 };
24540
24541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24543 if (!SWIG_IsOK(res1)) {
24544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24545 }
24546 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24547 ecode2 = SWIG_AsVal_int(obj1, &val2);
24548 if (!SWIG_IsOK(ecode2)) {
24549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24550 }
24551 arg2 = static_cast< int >(val2);
24552 {
24553 PyThreadState* __tstate = wxPyBeginAllowThreads();
24554 {
24555 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24556 result = (wxDateTime *) &_result_ref;
24557 }
24558 wxPyEndAllowThreads(__tstate);
24559 if (PyErr_Occurred()) SWIG_fail;
24560 }
24561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24562 return resultobj;
24563 fail:
24564 return NULL;
24565 }
24566
24567
24568 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24569 PyObject *resultobj = 0;
24570 wxDateTime *arg1 = (wxDateTime *) 0 ;
24571 int arg2 ;
24572 wxDateTime *result = 0 ;
24573 void *argp1 = 0 ;
24574 int res1 = 0 ;
24575 int val2 ;
24576 int ecode2 = 0 ;
24577 PyObject * obj0 = 0 ;
24578 PyObject * obj1 = 0 ;
24579 char * kwnames[] = {
24580 (char *) "self",(char *) "second", NULL
24581 };
24582
24583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24585 if (!SWIG_IsOK(res1)) {
24586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24587 }
24588 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24589 ecode2 = SWIG_AsVal_int(obj1, &val2);
24590 if (!SWIG_IsOK(ecode2)) {
24591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24592 }
24593 arg2 = static_cast< int >(val2);
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 {
24597 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24598 result = (wxDateTime *) &_result_ref;
24599 }
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj = 0;
24612 wxDateTime *arg1 = (wxDateTime *) 0 ;
24613 int arg2 ;
24614 wxDateTime *result = 0 ;
24615 void *argp1 = 0 ;
24616 int res1 = 0 ;
24617 int val2 ;
24618 int ecode2 = 0 ;
24619 PyObject * obj0 = 0 ;
24620 PyObject * obj1 = 0 ;
24621 char * kwnames[] = {
24622 (char *) "self",(char *) "millisecond", NULL
24623 };
24624
24625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24627 if (!SWIG_IsOK(res1)) {
24628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24629 }
24630 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24631 ecode2 = SWIG_AsVal_int(obj1, &val2);
24632 if (!SWIG_IsOK(ecode2)) {
24633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24634 }
24635 arg2 = static_cast< int >(val2);
24636 {
24637 PyThreadState* __tstate = wxPyBeginAllowThreads();
24638 {
24639 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24640 result = (wxDateTime *) &_result_ref;
24641 }
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj = 0;
24654 wxDateTime *arg1 = (wxDateTime *) 0 ;
24655 wxDateTime::WeekDay arg2 ;
24656 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24657 wxDateTime *result = 0 ;
24658 void *argp1 = 0 ;
24659 int res1 = 0 ;
24660 int val2 ;
24661 int ecode2 = 0 ;
24662 int val3 ;
24663 int ecode3 = 0 ;
24664 PyObject * obj0 = 0 ;
24665 PyObject * obj1 = 0 ;
24666 PyObject * obj2 = 0 ;
24667 char * kwnames[] = {
24668 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24669 };
24670
24671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24673 if (!SWIG_IsOK(res1)) {
24674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24675 }
24676 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24677 ecode2 = SWIG_AsVal_int(obj1, &val2);
24678 if (!SWIG_IsOK(ecode2)) {
24679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24680 }
24681 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24682 if (obj2) {
24683 ecode3 = SWIG_AsVal_int(obj2, &val3);
24684 if (!SWIG_IsOK(ecode3)) {
24685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24686 }
24687 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24688 }
24689 {
24690 PyThreadState* __tstate = wxPyBeginAllowThreads();
24691 {
24692 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24693 result = (wxDateTime *) &_result_ref;
24694 }
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24699 return resultobj;
24700 fail:
24701 return NULL;
24702 }
24703
24704
24705 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24706 PyObject *resultobj = 0;
24707 wxDateTime *arg1 = (wxDateTime *) 0 ;
24708 wxDateTime::WeekDay arg2 ;
24709 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24710 wxDateTime result;
24711 void *argp1 = 0 ;
24712 int res1 = 0 ;
24713 int val2 ;
24714 int ecode2 = 0 ;
24715 int val3 ;
24716 int ecode3 = 0 ;
24717 PyObject * obj0 = 0 ;
24718 PyObject * obj1 = 0 ;
24719 PyObject * obj2 = 0 ;
24720 char * kwnames[] = {
24721 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24722 };
24723
24724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24726 if (!SWIG_IsOK(res1)) {
24727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24728 }
24729 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24730 ecode2 = SWIG_AsVal_int(obj1, &val2);
24731 if (!SWIG_IsOK(ecode2)) {
24732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24733 }
24734 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24735 if (obj2) {
24736 ecode3 = SWIG_AsVal_int(obj2, &val3);
24737 if (!SWIG_IsOK(ecode3)) {
24738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24739 }
24740 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24741 }
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj = 0;
24757 wxDateTime *arg1 = (wxDateTime *) 0 ;
24758 wxDateTime::WeekDay arg2 ;
24759 wxDateTime *result = 0 ;
24760 void *argp1 = 0 ;
24761 int res1 = 0 ;
24762 int val2 ;
24763 int ecode2 = 0 ;
24764 PyObject * obj0 = 0 ;
24765 PyObject * obj1 = 0 ;
24766 char * kwnames[] = {
24767 (char *) "self",(char *) "weekday", NULL
24768 };
24769
24770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24772 if (!SWIG_IsOK(res1)) {
24773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24774 }
24775 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24776 ecode2 = SWIG_AsVal_int(obj1, &val2);
24777 if (!SWIG_IsOK(ecode2)) {
24778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24779 }
24780 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24781 {
24782 PyThreadState* __tstate = wxPyBeginAllowThreads();
24783 {
24784 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24785 result = (wxDateTime *) &_result_ref;
24786 }
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24798 PyObject *resultobj = 0;
24799 wxDateTime *arg1 = (wxDateTime *) 0 ;
24800 wxDateTime::WeekDay arg2 ;
24801 wxDateTime result;
24802 void *argp1 = 0 ;
24803 int res1 = 0 ;
24804 int val2 ;
24805 int ecode2 = 0 ;
24806 PyObject * obj0 = 0 ;
24807 PyObject * obj1 = 0 ;
24808 char * kwnames[] = {
24809 (char *) "self",(char *) "weekday", NULL
24810 };
24811
24812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24814 if (!SWIG_IsOK(res1)) {
24815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24816 }
24817 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24818 ecode2 = SWIG_AsVal_int(obj1, &val2);
24819 if (!SWIG_IsOK(ecode2)) {
24820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24821 }
24822 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = (arg1)->GetNextWeekDay(arg2);
24826 wxPyEndAllowThreads(__tstate);
24827 if (PyErr_Occurred()) SWIG_fail;
24828 }
24829 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24837 PyObject *resultobj = 0;
24838 wxDateTime *arg1 = (wxDateTime *) 0 ;
24839 wxDateTime::WeekDay arg2 ;
24840 wxDateTime *result = 0 ;
24841 void *argp1 = 0 ;
24842 int res1 = 0 ;
24843 int val2 ;
24844 int ecode2 = 0 ;
24845 PyObject * obj0 = 0 ;
24846 PyObject * obj1 = 0 ;
24847 char * kwnames[] = {
24848 (char *) "self",(char *) "weekday", NULL
24849 };
24850
24851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24853 if (!SWIG_IsOK(res1)) {
24854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24855 }
24856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24857 ecode2 = SWIG_AsVal_int(obj1, &val2);
24858 if (!SWIG_IsOK(ecode2)) {
24859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24860 }
24861 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24862 {
24863 PyThreadState* __tstate = wxPyBeginAllowThreads();
24864 {
24865 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24866 result = (wxDateTime *) &_result_ref;
24867 }
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj = 0;
24880 wxDateTime *arg1 = (wxDateTime *) 0 ;
24881 wxDateTime::WeekDay arg2 ;
24882 wxDateTime result;
24883 void *argp1 = 0 ;
24884 int res1 = 0 ;
24885 int val2 ;
24886 int ecode2 = 0 ;
24887 PyObject * obj0 = 0 ;
24888 PyObject * obj1 = 0 ;
24889 char * kwnames[] = {
24890 (char *) "self",(char *) "weekday", NULL
24891 };
24892
24893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24895 if (!SWIG_IsOK(res1)) {
24896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24897 }
24898 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24899 ecode2 = SWIG_AsVal_int(obj1, &val2);
24900 if (!SWIG_IsOK(ecode2)) {
24901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24902 }
24903 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (arg1)->GetPrevWeekDay(arg2);
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24918 PyObject *resultobj = 0;
24919 wxDateTime *arg1 = (wxDateTime *) 0 ;
24920 wxDateTime::WeekDay arg2 ;
24921 int arg3 = (int) 1 ;
24922 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24923 int arg5 = (int) wxDateTime::Inv_Year ;
24924 bool result;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 int val2 ;
24928 int ecode2 = 0 ;
24929 int val3 ;
24930 int ecode3 = 0 ;
24931 int val4 ;
24932 int ecode4 = 0 ;
24933 int val5 ;
24934 int ecode5 = 0 ;
24935 PyObject * obj0 = 0 ;
24936 PyObject * obj1 = 0 ;
24937 PyObject * obj2 = 0 ;
24938 PyObject * obj3 = 0 ;
24939 PyObject * obj4 = 0 ;
24940 char * kwnames[] = {
24941 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24942 };
24943
24944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24946 if (!SWIG_IsOK(res1)) {
24947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24948 }
24949 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24950 ecode2 = SWIG_AsVal_int(obj1, &val2);
24951 if (!SWIG_IsOK(ecode2)) {
24952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24953 }
24954 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24955 if (obj2) {
24956 ecode3 = SWIG_AsVal_int(obj2, &val3);
24957 if (!SWIG_IsOK(ecode3)) {
24958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24959 }
24960 arg3 = static_cast< int >(val3);
24961 }
24962 if (obj3) {
24963 ecode4 = SWIG_AsVal_int(obj3, &val4);
24964 if (!SWIG_IsOK(ecode4)) {
24965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24966 }
24967 arg4 = static_cast< wxDateTime::Month >(val4);
24968 }
24969 if (obj4) {
24970 ecode5 = SWIG_AsVal_int(obj4, &val5);
24971 if (!SWIG_IsOK(ecode5)) {
24972 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24973 }
24974 arg5 = static_cast< int >(val5);
24975 }
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 {
24983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24984 }
24985 return resultobj;
24986 fail:
24987 return NULL;
24988 }
24989
24990
24991 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24992 PyObject *resultobj = 0;
24993 wxDateTime *arg1 = (wxDateTime *) 0 ;
24994 wxDateTime::WeekDay arg2 ;
24995 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24996 int arg4 = (int) wxDateTime::Inv_Year ;
24997 bool result;
24998 void *argp1 = 0 ;
24999 int res1 = 0 ;
25000 int val2 ;
25001 int ecode2 = 0 ;
25002 int val3 ;
25003 int ecode3 = 0 ;
25004 int val4 ;
25005 int ecode4 = 0 ;
25006 PyObject * obj0 = 0 ;
25007 PyObject * obj1 = 0 ;
25008 PyObject * obj2 = 0 ;
25009 PyObject * obj3 = 0 ;
25010 char * kwnames[] = {
25011 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25012 };
25013
25014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25016 if (!SWIG_IsOK(res1)) {
25017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25018 }
25019 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25020 ecode2 = SWIG_AsVal_int(obj1, &val2);
25021 if (!SWIG_IsOK(ecode2)) {
25022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25023 }
25024 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25025 if (obj2) {
25026 ecode3 = SWIG_AsVal_int(obj2, &val3);
25027 if (!SWIG_IsOK(ecode3)) {
25028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25029 }
25030 arg3 = static_cast< wxDateTime::Month >(val3);
25031 }
25032 if (obj3) {
25033 ecode4 = SWIG_AsVal_int(obj3, &val4);
25034 if (!SWIG_IsOK(ecode4)) {
25035 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25036 }
25037 arg4 = static_cast< int >(val4);
25038 }
25039 {
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25042 wxPyEndAllowThreads(__tstate);
25043 if (PyErr_Occurred()) SWIG_fail;
25044 }
25045 {
25046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25047 }
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj = 0;
25056 wxDateTime *arg1 = (wxDateTime *) 0 ;
25057 wxDateTime::WeekDay arg2 ;
25058 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25059 int arg4 = (int) wxDateTime::Inv_Year ;
25060 wxDateTime result;
25061 void *argp1 = 0 ;
25062 int res1 = 0 ;
25063 int val2 ;
25064 int ecode2 = 0 ;
25065 int val3 ;
25066 int ecode3 = 0 ;
25067 int val4 ;
25068 int ecode4 = 0 ;
25069 PyObject * obj0 = 0 ;
25070 PyObject * obj1 = 0 ;
25071 PyObject * obj2 = 0 ;
25072 PyObject * obj3 = 0 ;
25073 char * kwnames[] = {
25074 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25075 };
25076
25077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25079 if (!SWIG_IsOK(res1)) {
25080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25081 }
25082 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25083 ecode2 = SWIG_AsVal_int(obj1, &val2);
25084 if (!SWIG_IsOK(ecode2)) {
25085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25086 }
25087 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25088 if (obj2) {
25089 ecode3 = SWIG_AsVal_int(obj2, &val3);
25090 if (!SWIG_IsOK(ecode3)) {
25091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25092 }
25093 arg3 = static_cast< wxDateTime::Month >(val3);
25094 }
25095 if (obj3) {
25096 ecode4 = SWIG_AsVal_int(obj3, &val4);
25097 if (!SWIG_IsOK(ecode4)) {
25098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25099 }
25100 arg4 = static_cast< int >(val4);
25101 }
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25109 return resultobj;
25110 fail:
25111 return NULL;
25112 }
25113
25114
25115 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25116 PyObject *resultobj = 0;
25117 wxDateTime *arg1 = (wxDateTime *) 0 ;
25118 int arg2 ;
25119 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25120 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25121 bool result;
25122 void *argp1 = 0 ;
25123 int res1 = 0 ;
25124 int val2 ;
25125 int ecode2 = 0 ;
25126 int val3 ;
25127 int ecode3 = 0 ;
25128 int val4 ;
25129 int ecode4 = 0 ;
25130 PyObject * obj0 = 0 ;
25131 PyObject * obj1 = 0 ;
25132 PyObject * obj2 = 0 ;
25133 PyObject * obj3 = 0 ;
25134 char * kwnames[] = {
25135 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25136 };
25137
25138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25140 if (!SWIG_IsOK(res1)) {
25141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25142 }
25143 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25144 ecode2 = SWIG_AsVal_int(obj1, &val2);
25145 if (!SWIG_IsOK(ecode2)) {
25146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25147 }
25148 arg2 = static_cast< int >(val2);
25149 if (obj2) {
25150 ecode3 = SWIG_AsVal_int(obj2, &val3);
25151 if (!SWIG_IsOK(ecode3)) {
25152 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25153 }
25154 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25155 }
25156 if (obj3) {
25157 ecode4 = SWIG_AsVal_int(obj3, &val4);
25158 if (!SWIG_IsOK(ecode4)) {
25159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25160 }
25161 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25162 }
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 {
25170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25171 }
25172 return resultobj;
25173 fail:
25174 return NULL;
25175 }
25176
25177
25178 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25179 PyObject *resultobj = 0;
25180 wxDateTime *arg1 = (wxDateTime *) 0 ;
25181 int arg2 ;
25182 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25183 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25184 wxDateTime result;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 int val2 ;
25188 int ecode2 = 0 ;
25189 int val3 ;
25190 int ecode3 = 0 ;
25191 int val4 ;
25192 int ecode4 = 0 ;
25193 PyObject * obj0 = 0 ;
25194 PyObject * obj1 = 0 ;
25195 PyObject * obj2 = 0 ;
25196 PyObject * obj3 = 0 ;
25197 char * kwnames[] = {
25198 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25199 };
25200
25201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25203 if (!SWIG_IsOK(res1)) {
25204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25205 }
25206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25207 ecode2 = SWIG_AsVal_int(obj1, &val2);
25208 if (!SWIG_IsOK(ecode2)) {
25209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25210 }
25211 arg2 = static_cast< int >(val2);
25212 if (obj2) {
25213 ecode3 = SWIG_AsVal_int(obj2, &val3);
25214 if (!SWIG_IsOK(ecode3)) {
25215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25216 }
25217 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25218 }
25219 if (obj3) {
25220 ecode4 = SWIG_AsVal_int(obj3, &val4);
25221 if (!SWIG_IsOK(ecode4)) {
25222 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25223 }
25224 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25225 }
25226 {
25227 PyThreadState* __tstate = wxPyBeginAllowThreads();
25228 result = (arg1)->GetWeek(arg2,arg3,arg4);
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj = 0;
25241 int arg1 ;
25242 int arg2 ;
25243 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25244 wxDateTime result;
25245 int val1 ;
25246 int ecode1 = 0 ;
25247 int val2 ;
25248 int ecode2 = 0 ;
25249 int val3 ;
25250 int ecode3 = 0 ;
25251 PyObject * obj0 = 0 ;
25252 PyObject * obj1 = 0 ;
25253 PyObject * obj2 = 0 ;
25254 char * kwnames[] = {
25255 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25256 };
25257
25258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25259 ecode1 = SWIG_AsVal_int(obj0, &val1);
25260 if (!SWIG_IsOK(ecode1)) {
25261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25262 }
25263 arg1 = static_cast< int >(val1);
25264 ecode2 = SWIG_AsVal_int(obj1, &val2);
25265 if (!SWIG_IsOK(ecode2)) {
25266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25267 }
25268 arg2 = static_cast< int >(val2);
25269 if (obj2) {
25270 ecode3 = SWIG_AsVal_int(obj2, &val3);
25271 if (!SWIG_IsOK(ecode3)) {
25272 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25273 }
25274 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25275 }
25276 {
25277 PyThreadState* __tstate = wxPyBeginAllowThreads();
25278 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25279 wxPyEndAllowThreads(__tstate);
25280 if (PyErr_Occurred()) SWIG_fail;
25281 }
25282 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25283 return resultobj;
25284 fail:
25285 return NULL;
25286 }
25287
25288
25289 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25290 PyObject *resultobj = 0;
25291 wxDateTime *arg1 = (wxDateTime *) 0 ;
25292 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25293 int arg3 = (int) wxDateTime::Inv_Year ;
25294 wxDateTime *result = 0 ;
25295 void *argp1 = 0 ;
25296 int res1 = 0 ;
25297 int val2 ;
25298 int ecode2 = 0 ;
25299 int val3 ;
25300 int ecode3 = 0 ;
25301 PyObject * obj0 = 0 ;
25302 PyObject * obj1 = 0 ;
25303 PyObject * obj2 = 0 ;
25304 char * kwnames[] = {
25305 (char *) "self",(char *) "month",(char *) "year", NULL
25306 };
25307
25308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25310 if (!SWIG_IsOK(res1)) {
25311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25312 }
25313 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25314 if (obj1) {
25315 ecode2 = SWIG_AsVal_int(obj1, &val2);
25316 if (!SWIG_IsOK(ecode2)) {
25317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25318 }
25319 arg2 = static_cast< wxDateTime::Month >(val2);
25320 }
25321 if (obj2) {
25322 ecode3 = SWIG_AsVal_int(obj2, &val3);
25323 if (!SWIG_IsOK(ecode3)) {
25324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25325 }
25326 arg3 = static_cast< int >(val3);
25327 }
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 {
25331 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25332 result = (wxDateTime *) &_result_ref;
25333 }
25334 wxPyEndAllowThreads(__tstate);
25335 if (PyErr_Occurred()) SWIG_fail;
25336 }
25337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25338 return resultobj;
25339 fail:
25340 return NULL;
25341 }
25342
25343
25344 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25345 PyObject *resultobj = 0;
25346 wxDateTime *arg1 = (wxDateTime *) 0 ;
25347 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25348 int arg3 = (int) wxDateTime::Inv_Year ;
25349 wxDateTime result;
25350 void *argp1 = 0 ;
25351 int res1 = 0 ;
25352 int val2 ;
25353 int ecode2 = 0 ;
25354 int val3 ;
25355 int ecode3 = 0 ;
25356 PyObject * obj0 = 0 ;
25357 PyObject * obj1 = 0 ;
25358 PyObject * obj2 = 0 ;
25359 char * kwnames[] = {
25360 (char *) "self",(char *) "month",(char *) "year", NULL
25361 };
25362
25363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25365 if (!SWIG_IsOK(res1)) {
25366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25367 }
25368 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25369 if (obj1) {
25370 ecode2 = SWIG_AsVal_int(obj1, &val2);
25371 if (!SWIG_IsOK(ecode2)) {
25372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25373 }
25374 arg2 = static_cast< wxDateTime::Month >(val2);
25375 }
25376 if (obj2) {
25377 ecode3 = SWIG_AsVal_int(obj2, &val3);
25378 if (!SWIG_IsOK(ecode3)) {
25379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25380 }
25381 arg3 = static_cast< int >(val3);
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = (arg1)->GetLastMonthDay(arg2,arg3);
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25397 PyObject *resultobj = 0;
25398 wxDateTime *arg1 = (wxDateTime *) 0 ;
25399 int arg2 ;
25400 wxDateTime *result = 0 ;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 int val2 ;
25404 int ecode2 = 0 ;
25405 PyObject * obj0 = 0 ;
25406 PyObject * obj1 = 0 ;
25407 char * kwnames[] = {
25408 (char *) "self",(char *) "yday", NULL
25409 };
25410
25411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25413 if (!SWIG_IsOK(res1)) {
25414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25415 }
25416 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25417 ecode2 = SWIG_AsVal_int(obj1, &val2);
25418 if (!SWIG_IsOK(ecode2)) {
25419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25420 }
25421 arg2 = static_cast< int >(val2);
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 {
25425 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25426 result = (wxDateTime *) &_result_ref;
25427 }
25428 wxPyEndAllowThreads(__tstate);
25429 if (PyErr_Occurred()) SWIG_fail;
25430 }
25431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25432 return resultobj;
25433 fail:
25434 return NULL;
25435 }
25436
25437
25438 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25439 PyObject *resultobj = 0;
25440 wxDateTime *arg1 = (wxDateTime *) 0 ;
25441 int arg2 ;
25442 wxDateTime result;
25443 void *argp1 = 0 ;
25444 int res1 = 0 ;
25445 int val2 ;
25446 int ecode2 = 0 ;
25447 PyObject * obj0 = 0 ;
25448 PyObject * obj1 = 0 ;
25449 char * kwnames[] = {
25450 (char *) "self",(char *) "yday", NULL
25451 };
25452
25453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25455 if (!SWIG_IsOK(res1)) {
25456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25457 }
25458 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25459 ecode2 = SWIG_AsVal_int(obj1, &val2);
25460 if (!SWIG_IsOK(ecode2)) {
25461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25462 }
25463 arg2 = static_cast< int >(val2);
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 result = (arg1)->GetYearDay(arg2);
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25471 return resultobj;
25472 fail:
25473 return NULL;
25474 }
25475
25476
25477 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25478 PyObject *resultobj = 0;
25479 wxDateTime *arg1 = (wxDateTime *) 0 ;
25480 double result;
25481 void *argp1 = 0 ;
25482 int res1 = 0 ;
25483 PyObject *swig_obj[1] ;
25484
25485 if (!args) SWIG_fail;
25486 swig_obj[0] = args;
25487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25488 if (!SWIG_IsOK(res1)) {
25489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25490 }
25491 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25492 {
25493 PyThreadState* __tstate = wxPyBeginAllowThreads();
25494 result = (double)(arg1)->GetJulianDayNumber();
25495 wxPyEndAllowThreads(__tstate);
25496 if (PyErr_Occurred()) SWIG_fail;
25497 }
25498 resultobj = SWIG_From_double(static_cast< double >(result));
25499 return resultobj;
25500 fail:
25501 return NULL;
25502 }
25503
25504
25505 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25506 PyObject *resultobj = 0;
25507 wxDateTime *arg1 = (wxDateTime *) 0 ;
25508 double result;
25509 void *argp1 = 0 ;
25510 int res1 = 0 ;
25511 PyObject *swig_obj[1] ;
25512
25513 if (!args) SWIG_fail;
25514 swig_obj[0] = args;
25515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25516 if (!SWIG_IsOK(res1)) {
25517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25518 }
25519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 result = (double)(arg1)->GetJDN();
25523 wxPyEndAllowThreads(__tstate);
25524 if (PyErr_Occurred()) SWIG_fail;
25525 }
25526 resultobj = SWIG_From_double(static_cast< double >(result));
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25534 PyObject *resultobj = 0;
25535 wxDateTime *arg1 = (wxDateTime *) 0 ;
25536 double result;
25537 void *argp1 = 0 ;
25538 int res1 = 0 ;
25539 PyObject *swig_obj[1] ;
25540
25541 if (!args) SWIG_fail;
25542 swig_obj[0] = args;
25543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25544 if (!SWIG_IsOK(res1)) {
25545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25546 }
25547 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25548 {
25549 PyThreadState* __tstate = wxPyBeginAllowThreads();
25550 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25551 wxPyEndAllowThreads(__tstate);
25552 if (PyErr_Occurred()) SWIG_fail;
25553 }
25554 resultobj = SWIG_From_double(static_cast< double >(result));
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25562 PyObject *resultobj = 0;
25563 wxDateTime *arg1 = (wxDateTime *) 0 ;
25564 double result;
25565 void *argp1 = 0 ;
25566 int res1 = 0 ;
25567 PyObject *swig_obj[1] ;
25568
25569 if (!args) SWIG_fail;
25570 swig_obj[0] = args;
25571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25572 if (!SWIG_IsOK(res1)) {
25573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25574 }
25575 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (double)(arg1)->GetMJD();
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_From_double(static_cast< double >(result));
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25590 PyObject *resultobj = 0;
25591 wxDateTime *arg1 = (wxDateTime *) 0 ;
25592 double result;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 PyObject *swig_obj[1] ;
25596
25597 if (!args) SWIG_fail;
25598 swig_obj[0] = args;
25599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25600 if (!SWIG_IsOK(res1)) {
25601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25602 }
25603 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25604 {
25605 PyThreadState* __tstate = wxPyBeginAllowThreads();
25606 result = (double)(arg1)->GetRataDie();
25607 wxPyEndAllowThreads(__tstate);
25608 if (PyErr_Occurred()) SWIG_fail;
25609 }
25610 resultobj = SWIG_From_double(static_cast< double >(result));
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25618 PyObject *resultobj = 0;
25619 wxDateTime *arg1 = (wxDateTime *) 0 ;
25620 wxDateTime::TimeZone *arg2 = 0 ;
25621 bool arg3 = (bool) false ;
25622 wxDateTime result;
25623 void *argp1 = 0 ;
25624 int res1 = 0 ;
25625 bool temp2 = false ;
25626 bool val3 ;
25627 int ecode3 = 0 ;
25628 PyObject * obj0 = 0 ;
25629 PyObject * obj1 = 0 ;
25630 PyObject * obj2 = 0 ;
25631 char * kwnames[] = {
25632 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25633 };
25634
25635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25637 if (!SWIG_IsOK(res1)) {
25638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25639 }
25640 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25641 {
25642 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25643 temp2 = true;
25644 }
25645 if (obj2) {
25646 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25647 if (!SWIG_IsOK(ecode3)) {
25648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25649 }
25650 arg3 = static_cast< bool >(val3);
25651 }
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25659 {
25660 if (temp2) delete arg2;
25661 }
25662 return resultobj;
25663 fail:
25664 {
25665 if (temp2) delete arg2;
25666 }
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25672 PyObject *resultobj = 0;
25673 wxDateTime *arg1 = (wxDateTime *) 0 ;
25674 wxDateTime::TimeZone *arg2 = 0 ;
25675 bool arg3 = (bool) false ;
25676 wxDateTime *result = 0 ;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 bool temp2 = false ;
25680 bool val3 ;
25681 int ecode3 = 0 ;
25682 PyObject * obj0 = 0 ;
25683 PyObject * obj1 = 0 ;
25684 PyObject * obj2 = 0 ;
25685 char * kwnames[] = {
25686 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25687 };
25688
25689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25691 if (!SWIG_IsOK(res1)) {
25692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25693 }
25694 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25695 {
25696 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25697 temp2 = true;
25698 }
25699 if (obj2) {
25700 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25701 if (!SWIG_IsOK(ecode3)) {
25702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25703 }
25704 arg3 = static_cast< bool >(val3);
25705 }
25706 {
25707 PyThreadState* __tstate = wxPyBeginAllowThreads();
25708 {
25709 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25710 result = (wxDateTime *) &_result_ref;
25711 }
25712 wxPyEndAllowThreads(__tstate);
25713 if (PyErr_Occurred()) SWIG_fail;
25714 }
25715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25716 {
25717 if (temp2) delete arg2;
25718 }
25719 return resultobj;
25720 fail:
25721 {
25722 if (temp2) delete arg2;
25723 }
25724 return NULL;
25725 }
25726
25727
25728 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25729 PyObject *resultobj = 0;
25730 wxDateTime *arg1 = (wxDateTime *) 0 ;
25731 wxDateTime::TimeZone *arg2 = 0 ;
25732 bool arg3 = (bool) false ;
25733 wxDateTime result;
25734 void *argp1 = 0 ;
25735 int res1 = 0 ;
25736 bool temp2 = false ;
25737 bool val3 ;
25738 int ecode3 = 0 ;
25739 PyObject * obj0 = 0 ;
25740 PyObject * obj1 = 0 ;
25741 PyObject * obj2 = 0 ;
25742 char * kwnames[] = {
25743 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25744 };
25745
25746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25748 if (!SWIG_IsOK(res1)) {
25749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25750 }
25751 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25752 {
25753 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25754 temp2 = true;
25755 }
25756 if (obj2) {
25757 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25758 if (!SWIG_IsOK(ecode3)) {
25759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25760 }
25761 arg3 = static_cast< bool >(val3);
25762 }
25763 {
25764 PyThreadState* __tstate = wxPyBeginAllowThreads();
25765 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25766 wxPyEndAllowThreads(__tstate);
25767 if (PyErr_Occurred()) SWIG_fail;
25768 }
25769 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25770 {
25771 if (temp2) delete arg2;
25772 }
25773 return resultobj;
25774 fail:
25775 {
25776 if (temp2) delete arg2;
25777 }
25778 return NULL;
25779 }
25780
25781
25782 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25783 PyObject *resultobj = 0;
25784 wxDateTime *arg1 = (wxDateTime *) 0 ;
25785 wxDateTime::TimeZone *arg2 = 0 ;
25786 bool arg3 = (bool) false ;
25787 wxDateTime *result = 0 ;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 bool temp2 = false ;
25791 bool val3 ;
25792 int ecode3 = 0 ;
25793 PyObject * obj0 = 0 ;
25794 PyObject * obj1 = 0 ;
25795 PyObject * obj2 = 0 ;
25796 char * kwnames[] = {
25797 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25798 };
25799
25800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25802 if (!SWIG_IsOK(res1)) {
25803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25804 }
25805 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25806 {
25807 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25808 temp2 = true;
25809 }
25810 if (obj2) {
25811 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25812 if (!SWIG_IsOK(ecode3)) {
25813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25814 }
25815 arg3 = static_cast< bool >(val3);
25816 }
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 {
25820 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25821 result = (wxDateTime *) &_result_ref;
25822 }
25823 wxPyEndAllowThreads(__tstate);
25824 if (PyErr_Occurred()) SWIG_fail;
25825 }
25826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25827 {
25828 if (temp2) delete arg2;
25829 }
25830 return resultobj;
25831 fail:
25832 {
25833 if (temp2) delete arg2;
25834 }
25835 return NULL;
25836 }
25837
25838
25839 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25840 PyObject *resultobj = 0;
25841 wxDateTime *arg1 = (wxDateTime *) 0 ;
25842 bool arg2 = (bool) false ;
25843 wxDateTime result;
25844 void *argp1 = 0 ;
25845 int res1 = 0 ;
25846 bool val2 ;
25847 int ecode2 = 0 ;
25848 PyObject * obj0 = 0 ;
25849 PyObject * obj1 = 0 ;
25850 char * kwnames[] = {
25851 (char *) "self",(char *) "noDST", NULL
25852 };
25853
25854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25856 if (!SWIG_IsOK(res1)) {
25857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25858 }
25859 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25860 if (obj1) {
25861 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25862 if (!SWIG_IsOK(ecode2)) {
25863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25864 }
25865 arg2 = static_cast< bool >(val2);
25866 }
25867 {
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25870 wxPyEndAllowThreads(__tstate);
25871 if (PyErr_Occurred()) SWIG_fail;
25872 }
25873 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25874 return resultobj;
25875 fail:
25876 return NULL;
25877 }
25878
25879
25880 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25881 PyObject *resultobj = 0;
25882 wxDateTime *arg1 = (wxDateTime *) 0 ;
25883 bool arg2 = (bool) false ;
25884 wxDateTime *result = 0 ;
25885 void *argp1 = 0 ;
25886 int res1 = 0 ;
25887 bool val2 ;
25888 int ecode2 = 0 ;
25889 PyObject * obj0 = 0 ;
25890 PyObject * obj1 = 0 ;
25891 char * kwnames[] = {
25892 (char *) "self",(char *) "noDST", NULL
25893 };
25894
25895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25897 if (!SWIG_IsOK(res1)) {
25898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25899 }
25900 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25901 if (obj1) {
25902 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25903 if (!SWIG_IsOK(ecode2)) {
25904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25905 }
25906 arg2 = static_cast< bool >(val2);
25907 }
25908 {
25909 PyThreadState* __tstate = wxPyBeginAllowThreads();
25910 {
25911 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25912 result = (wxDateTime *) &_result_ref;
25913 }
25914 wxPyEndAllowThreads(__tstate);
25915 if (PyErr_Occurred()) SWIG_fail;
25916 }
25917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25918 return resultobj;
25919 fail:
25920 return NULL;
25921 }
25922
25923
25924 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25925 PyObject *resultobj = 0;
25926 wxDateTime *arg1 = (wxDateTime *) 0 ;
25927 bool arg2 = (bool) false ;
25928 wxDateTime result;
25929 void *argp1 = 0 ;
25930 int res1 = 0 ;
25931 bool val2 ;
25932 int ecode2 = 0 ;
25933 PyObject * obj0 = 0 ;
25934 PyObject * obj1 = 0 ;
25935 char * kwnames[] = {
25936 (char *) "self",(char *) "noDST", NULL
25937 };
25938
25939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25941 if (!SWIG_IsOK(res1)) {
25942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25943 }
25944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25945 if (obj1) {
25946 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25947 if (!SWIG_IsOK(ecode2)) {
25948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25949 }
25950 arg2 = static_cast< bool >(val2);
25951 }
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25955 wxPyEndAllowThreads(__tstate);
25956 if (PyErr_Occurred()) SWIG_fail;
25957 }
25958 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25959 return resultobj;
25960 fail:
25961 return NULL;
25962 }
25963
25964
25965 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25966 PyObject *resultobj = 0;
25967 wxDateTime *arg1 = (wxDateTime *) 0 ;
25968 bool arg2 = (bool) false ;
25969 wxDateTime *result = 0 ;
25970 void *argp1 = 0 ;
25971 int res1 = 0 ;
25972 bool val2 ;
25973 int ecode2 = 0 ;
25974 PyObject * obj0 = 0 ;
25975 PyObject * obj1 = 0 ;
25976 char * kwnames[] = {
25977 (char *) "self",(char *) "noDST", NULL
25978 };
25979
25980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25982 if (!SWIG_IsOK(res1)) {
25983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25984 }
25985 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25986 if (obj1) {
25987 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25988 if (!SWIG_IsOK(ecode2)) {
25989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25990 }
25991 arg2 = static_cast< bool >(val2);
25992 }
25993 {
25994 PyThreadState* __tstate = wxPyBeginAllowThreads();
25995 {
25996 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25997 result = (wxDateTime *) &_result_ref;
25998 }
25999 wxPyEndAllowThreads(__tstate);
26000 if (PyErr_Occurred()) SWIG_fail;
26001 }
26002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26003 return resultobj;
26004 fail:
26005 return NULL;
26006 }
26007
26008
26009 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26010 PyObject *resultobj = 0;
26011 wxDateTime *arg1 = (wxDateTime *) 0 ;
26012 bool arg2 = (bool) false ;
26013 wxDateTime result;
26014 void *argp1 = 0 ;
26015 int res1 = 0 ;
26016 bool val2 ;
26017 int ecode2 = 0 ;
26018 PyObject * obj0 = 0 ;
26019 PyObject * obj1 = 0 ;
26020 char * kwnames[] = {
26021 (char *) "self",(char *) "noDST", NULL
26022 };
26023
26024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26026 if (!SWIG_IsOK(res1)) {
26027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26028 }
26029 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26030 if (obj1) {
26031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26032 if (!SWIG_IsOK(ecode2)) {
26033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26034 }
26035 arg2 = static_cast< bool >(val2);
26036 }
26037 {
26038 PyThreadState* __tstate = wxPyBeginAllowThreads();
26039 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26040 wxPyEndAllowThreads(__tstate);
26041 if (PyErr_Occurred()) SWIG_fail;
26042 }
26043 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26044 return resultobj;
26045 fail:
26046 return NULL;
26047 }
26048
26049
26050 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26051 PyObject *resultobj = 0;
26052 wxDateTime *arg1 = (wxDateTime *) 0 ;
26053 bool arg2 = (bool) false ;
26054 wxDateTime *result = 0 ;
26055 void *argp1 = 0 ;
26056 int res1 = 0 ;
26057 bool val2 ;
26058 int ecode2 = 0 ;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 char * kwnames[] = {
26062 (char *) "self",(char *) "noDST", NULL
26063 };
26064
26065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26067 if (!SWIG_IsOK(res1)) {
26068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26069 }
26070 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26071 if (obj1) {
26072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26073 if (!SWIG_IsOK(ecode2)) {
26074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26075 }
26076 arg2 = static_cast< bool >(val2);
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 {
26081 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26082 result = (wxDateTime *) &_result_ref;
26083 }
26084 wxPyEndAllowThreads(__tstate);
26085 if (PyErr_Occurred()) SWIG_fail;
26086 }
26087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj = 0;
26096 wxDateTime *arg1 = (wxDateTime *) 0 ;
26097 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26098 int result;
26099 void *argp1 = 0 ;
26100 int res1 = 0 ;
26101 int val2 ;
26102 int ecode2 = 0 ;
26103 PyObject * obj0 = 0 ;
26104 PyObject * obj1 = 0 ;
26105 char * kwnames[] = {
26106 (char *) "self",(char *) "country", NULL
26107 };
26108
26109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26111 if (!SWIG_IsOK(res1)) {
26112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26113 }
26114 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26115 if (obj1) {
26116 ecode2 = SWIG_AsVal_int(obj1, &val2);
26117 if (!SWIG_IsOK(ecode2)) {
26118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26119 }
26120 arg2 = static_cast< wxDateTime::Country >(val2);
26121 }
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 result = (int)(arg1)->IsDST(arg2);
26125 wxPyEndAllowThreads(__tstate);
26126 if (PyErr_Occurred()) SWIG_fail;
26127 }
26128 resultobj = SWIG_From_int(static_cast< int >(result));
26129 return resultobj;
26130 fail:
26131 return NULL;
26132 }
26133
26134
26135 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26136 PyObject *resultobj = 0;
26137 wxDateTime *arg1 = (wxDateTime *) 0 ;
26138 bool result;
26139 void *argp1 = 0 ;
26140 int res1 = 0 ;
26141 PyObject *swig_obj[1] ;
26142
26143 if (!args) SWIG_fail;
26144 swig_obj[0] = args;
26145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26146 if (!SWIG_IsOK(res1)) {
26147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26148 }
26149 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26150 {
26151 PyThreadState* __tstate = wxPyBeginAllowThreads();
26152 result = (bool)((wxDateTime const *)arg1)->IsValid();
26153 wxPyEndAllowThreads(__tstate);
26154 if (PyErr_Occurred()) SWIG_fail;
26155 }
26156 {
26157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26158 }
26159 return resultobj;
26160 fail:
26161 return NULL;
26162 }
26163
26164
26165 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26166 PyObject *resultobj = 0;
26167 wxDateTime *arg1 = (wxDateTime *) 0 ;
26168 time_t result;
26169 void *argp1 = 0 ;
26170 int res1 = 0 ;
26171 PyObject *swig_obj[1] ;
26172
26173 if (!args) SWIG_fail;
26174 swig_obj[0] = args;
26175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26176 if (!SWIG_IsOK(res1)) {
26177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26178 }
26179 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26180 {
26181 PyThreadState* __tstate = wxPyBeginAllowThreads();
26182 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26183 wxPyEndAllowThreads(__tstate);
26184 if (PyErr_Occurred()) SWIG_fail;
26185 }
26186 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26187 return resultobj;
26188 fail:
26189 return NULL;
26190 }
26191
26192
26193 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26194 PyObject *resultobj = 0;
26195 wxDateTime *arg1 = (wxDateTime *) 0 ;
26196 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26197 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26198 int result;
26199 void *argp1 = 0 ;
26200 int res1 = 0 ;
26201 bool temp2 = false ;
26202 PyObject * obj0 = 0 ;
26203 PyObject * obj1 = 0 ;
26204 char * kwnames[] = {
26205 (char *) "self",(char *) "tz", NULL
26206 };
26207
26208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26210 if (!SWIG_IsOK(res1)) {
26211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26212 }
26213 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26214 if (obj1) {
26215 {
26216 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26217 temp2 = true;
26218 }
26219 }
26220 {
26221 PyThreadState* __tstate = wxPyBeginAllowThreads();
26222 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 resultobj = SWIG_From_int(static_cast< int >(result));
26227 {
26228 if (temp2) delete arg2;
26229 }
26230 return resultobj;
26231 fail:
26232 {
26233 if (temp2) delete arg2;
26234 }
26235 return NULL;
26236 }
26237
26238
26239 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26240 PyObject *resultobj = 0;
26241 wxDateTime *arg1 = (wxDateTime *) 0 ;
26242 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26243 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26244 wxDateTime::Month result;
26245 void *argp1 = 0 ;
26246 int res1 = 0 ;
26247 bool temp2 = false ;
26248 PyObject * obj0 = 0 ;
26249 PyObject * obj1 = 0 ;
26250 char * kwnames[] = {
26251 (char *) "self",(char *) "tz", NULL
26252 };
26253
26254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26256 if (!SWIG_IsOK(res1)) {
26257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26258 }
26259 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26260 if (obj1) {
26261 {
26262 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26263 temp2 = true;
26264 }
26265 }
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 resultobj = SWIG_From_int(static_cast< int >(result));
26273 {
26274 if (temp2) delete arg2;
26275 }
26276 return resultobj;
26277 fail:
26278 {
26279 if (temp2) delete arg2;
26280 }
26281 return NULL;
26282 }
26283
26284
26285 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26286 PyObject *resultobj = 0;
26287 wxDateTime *arg1 = (wxDateTime *) 0 ;
26288 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26289 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26290 int result;
26291 void *argp1 = 0 ;
26292 int res1 = 0 ;
26293 bool temp2 = false ;
26294 PyObject * obj0 = 0 ;
26295 PyObject * obj1 = 0 ;
26296 char * kwnames[] = {
26297 (char *) "self",(char *) "tz", NULL
26298 };
26299
26300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26302 if (!SWIG_IsOK(res1)) {
26303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26304 }
26305 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26306 if (obj1) {
26307 {
26308 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26309 temp2 = true;
26310 }
26311 }
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26315 wxPyEndAllowThreads(__tstate);
26316 if (PyErr_Occurred()) SWIG_fail;
26317 }
26318 resultobj = SWIG_From_int(static_cast< int >(result));
26319 {
26320 if (temp2) delete arg2;
26321 }
26322 return resultobj;
26323 fail:
26324 {
26325 if (temp2) delete arg2;
26326 }
26327 return NULL;
26328 }
26329
26330
26331 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26332 PyObject *resultobj = 0;
26333 wxDateTime *arg1 = (wxDateTime *) 0 ;
26334 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26335 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26336 wxDateTime::WeekDay result;
26337 void *argp1 = 0 ;
26338 int res1 = 0 ;
26339 bool temp2 = false ;
26340 PyObject * obj0 = 0 ;
26341 PyObject * obj1 = 0 ;
26342 char * kwnames[] = {
26343 (char *) "self",(char *) "tz", NULL
26344 };
26345
26346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26348 if (!SWIG_IsOK(res1)) {
26349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26350 }
26351 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26352 if (obj1) {
26353 {
26354 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26355 temp2 = true;
26356 }
26357 }
26358 {
26359 PyThreadState* __tstate = wxPyBeginAllowThreads();
26360 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26361 wxPyEndAllowThreads(__tstate);
26362 if (PyErr_Occurred()) SWIG_fail;
26363 }
26364 resultobj = SWIG_From_int(static_cast< int >(result));
26365 {
26366 if (temp2) delete arg2;
26367 }
26368 return resultobj;
26369 fail:
26370 {
26371 if (temp2) delete arg2;
26372 }
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26378 PyObject *resultobj = 0;
26379 wxDateTime *arg1 = (wxDateTime *) 0 ;
26380 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26381 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26382 int result;
26383 void *argp1 = 0 ;
26384 int res1 = 0 ;
26385 bool temp2 = false ;
26386 PyObject * obj0 = 0 ;
26387 PyObject * obj1 = 0 ;
26388 char * kwnames[] = {
26389 (char *) "self",(char *) "tz", NULL
26390 };
26391
26392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26394 if (!SWIG_IsOK(res1)) {
26395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26396 }
26397 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26398 if (obj1) {
26399 {
26400 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26401 temp2 = true;
26402 }
26403 }
26404 {
26405 PyThreadState* __tstate = wxPyBeginAllowThreads();
26406 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26407 wxPyEndAllowThreads(__tstate);
26408 if (PyErr_Occurred()) SWIG_fail;
26409 }
26410 resultobj = SWIG_From_int(static_cast< int >(result));
26411 {
26412 if (temp2) delete arg2;
26413 }
26414 return resultobj;
26415 fail:
26416 {
26417 if (temp2) delete arg2;
26418 }
26419 return NULL;
26420 }
26421
26422
26423 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26424 PyObject *resultobj = 0;
26425 wxDateTime *arg1 = (wxDateTime *) 0 ;
26426 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26427 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26428 int result;
26429 void *argp1 = 0 ;
26430 int res1 = 0 ;
26431 bool temp2 = false ;
26432 PyObject * obj0 = 0 ;
26433 PyObject * obj1 = 0 ;
26434 char * kwnames[] = {
26435 (char *) "self",(char *) "tz", NULL
26436 };
26437
26438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26440 if (!SWIG_IsOK(res1)) {
26441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26442 }
26443 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26444 if (obj1) {
26445 {
26446 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26447 temp2 = true;
26448 }
26449 }
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26453 wxPyEndAllowThreads(__tstate);
26454 if (PyErr_Occurred()) SWIG_fail;
26455 }
26456 resultobj = SWIG_From_int(static_cast< int >(result));
26457 {
26458 if (temp2) delete arg2;
26459 }
26460 return resultobj;
26461 fail:
26462 {
26463 if (temp2) delete arg2;
26464 }
26465 return NULL;
26466 }
26467
26468
26469 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26470 PyObject *resultobj = 0;
26471 wxDateTime *arg1 = (wxDateTime *) 0 ;
26472 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26473 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26474 int result;
26475 void *argp1 = 0 ;
26476 int res1 = 0 ;
26477 bool temp2 = false ;
26478 PyObject * obj0 = 0 ;
26479 PyObject * obj1 = 0 ;
26480 char * kwnames[] = {
26481 (char *) "self",(char *) "tz", NULL
26482 };
26483
26484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26486 if (!SWIG_IsOK(res1)) {
26487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26488 }
26489 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26490 if (obj1) {
26491 {
26492 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26493 temp2 = true;
26494 }
26495 }
26496 {
26497 PyThreadState* __tstate = wxPyBeginAllowThreads();
26498 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26499 wxPyEndAllowThreads(__tstate);
26500 if (PyErr_Occurred()) SWIG_fail;
26501 }
26502 resultobj = SWIG_From_int(static_cast< int >(result));
26503 {
26504 if (temp2) delete arg2;
26505 }
26506 return resultobj;
26507 fail:
26508 {
26509 if (temp2) delete arg2;
26510 }
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26516 PyObject *resultobj = 0;
26517 wxDateTime *arg1 = (wxDateTime *) 0 ;
26518 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26519 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26520 int result;
26521 void *argp1 = 0 ;
26522 int res1 = 0 ;
26523 bool temp2 = false ;
26524 PyObject * obj0 = 0 ;
26525 PyObject * obj1 = 0 ;
26526 char * kwnames[] = {
26527 (char *) "self",(char *) "tz", NULL
26528 };
26529
26530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26532 if (!SWIG_IsOK(res1)) {
26533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26534 }
26535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26536 if (obj1) {
26537 {
26538 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26539 temp2 = true;
26540 }
26541 }
26542 {
26543 PyThreadState* __tstate = wxPyBeginAllowThreads();
26544 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26545 wxPyEndAllowThreads(__tstate);
26546 if (PyErr_Occurred()) SWIG_fail;
26547 }
26548 resultobj = SWIG_From_int(static_cast< int >(result));
26549 {
26550 if (temp2) delete arg2;
26551 }
26552 return resultobj;
26553 fail:
26554 {
26555 if (temp2) delete arg2;
26556 }
26557 return NULL;
26558 }
26559
26560
26561 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26562 PyObject *resultobj = 0;
26563 wxDateTime *arg1 = (wxDateTime *) 0 ;
26564 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26565 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26566 int result;
26567 void *argp1 = 0 ;
26568 int res1 = 0 ;
26569 bool temp2 = false ;
26570 PyObject * obj0 = 0 ;
26571 PyObject * obj1 = 0 ;
26572 char * kwnames[] = {
26573 (char *) "self",(char *) "tz", NULL
26574 };
26575
26576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26578 if (!SWIG_IsOK(res1)) {
26579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26580 }
26581 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26582 if (obj1) {
26583 {
26584 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26585 temp2 = true;
26586 }
26587 }
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26591 wxPyEndAllowThreads(__tstate);
26592 if (PyErr_Occurred()) SWIG_fail;
26593 }
26594 resultobj = SWIG_From_int(static_cast< int >(result));
26595 {
26596 if (temp2) delete arg2;
26597 }
26598 return resultobj;
26599 fail:
26600 {
26601 if (temp2) delete arg2;
26602 }
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj = 0;
26609 wxDateTime *arg1 = (wxDateTime *) 0 ;
26610 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26611 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26612 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26613 int result;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 int val2 ;
26617 int ecode2 = 0 ;
26618 bool temp3 = false ;
26619 PyObject * obj0 = 0 ;
26620 PyObject * obj1 = 0 ;
26621 PyObject * obj2 = 0 ;
26622 char * kwnames[] = {
26623 (char *) "self",(char *) "flags",(char *) "tz", NULL
26624 };
26625
26626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26628 if (!SWIG_IsOK(res1)) {
26629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26630 }
26631 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26632 if (obj1) {
26633 ecode2 = SWIG_AsVal_int(obj1, &val2);
26634 if (!SWIG_IsOK(ecode2)) {
26635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26636 }
26637 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26638 }
26639 if (obj2) {
26640 {
26641 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26642 temp3 = true;
26643 }
26644 }
26645 {
26646 PyThreadState* __tstate = wxPyBeginAllowThreads();
26647 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26648 wxPyEndAllowThreads(__tstate);
26649 if (PyErr_Occurred()) SWIG_fail;
26650 }
26651 resultobj = SWIG_From_int(static_cast< int >(result));
26652 {
26653 if (temp3) delete arg3;
26654 }
26655 return resultobj;
26656 fail:
26657 {
26658 if (temp3) delete arg3;
26659 }
26660 return NULL;
26661 }
26662
26663
26664 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26665 PyObject *resultobj = 0;
26666 wxDateTime *arg1 = (wxDateTime *) 0 ;
26667 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26668 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26669 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26670 int result;
26671 void *argp1 = 0 ;
26672 int res1 = 0 ;
26673 int val2 ;
26674 int ecode2 = 0 ;
26675 bool temp3 = false ;
26676 PyObject * obj0 = 0 ;
26677 PyObject * obj1 = 0 ;
26678 PyObject * obj2 = 0 ;
26679 char * kwnames[] = {
26680 (char *) "self",(char *) "flags",(char *) "tz", NULL
26681 };
26682
26683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26685 if (!SWIG_IsOK(res1)) {
26686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26687 }
26688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26689 if (obj1) {
26690 ecode2 = SWIG_AsVal_int(obj1, &val2);
26691 if (!SWIG_IsOK(ecode2)) {
26692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26693 }
26694 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26695 }
26696 if (obj2) {
26697 {
26698 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26699 temp3 = true;
26700 }
26701 }
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26705 wxPyEndAllowThreads(__tstate);
26706 if (PyErr_Occurred()) SWIG_fail;
26707 }
26708 resultobj = SWIG_From_int(static_cast< int >(result));
26709 {
26710 if (temp3) delete arg3;
26711 }
26712 return resultobj;
26713 fail:
26714 {
26715 if (temp3) delete arg3;
26716 }
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj = 0;
26723 wxDateTime *arg1 = (wxDateTime *) 0 ;
26724 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26725 bool result;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 int val2 ;
26729 int ecode2 = 0 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 char * kwnames[] = {
26733 (char *) "self",(char *) "country", NULL
26734 };
26735
26736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26738 if (!SWIG_IsOK(res1)) {
26739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26740 }
26741 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26742 if (obj1) {
26743 ecode2 = SWIG_AsVal_int(obj1, &val2);
26744 if (!SWIG_IsOK(ecode2)) {
26745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26746 }
26747 arg2 = static_cast< wxDateTime::Country >(val2);
26748 }
26749 {
26750 PyThreadState* __tstate = wxPyBeginAllowThreads();
26751 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26752 wxPyEndAllowThreads(__tstate);
26753 if (PyErr_Occurred()) SWIG_fail;
26754 }
26755 {
26756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26757 }
26758 return resultobj;
26759 fail:
26760 return NULL;
26761 }
26762
26763
26764 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26765 PyObject *resultobj = 0;
26766 wxDateTime *arg1 = (wxDateTime *) 0 ;
26767 wxDateTime *arg2 = 0 ;
26768 bool result;
26769 void *argp1 = 0 ;
26770 int res1 = 0 ;
26771 void *argp2 = 0 ;
26772 int res2 = 0 ;
26773 PyObject * obj0 = 0 ;
26774 PyObject * obj1 = 0 ;
26775 char * kwnames[] = {
26776 (char *) "self",(char *) "datetime", NULL
26777 };
26778
26779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26781 if (!SWIG_IsOK(res1)) {
26782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26783 }
26784 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26786 if (!SWIG_IsOK(res2)) {
26787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26788 }
26789 if (!argp2) {
26790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26791 }
26792 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26793 {
26794 PyThreadState* __tstate = wxPyBeginAllowThreads();
26795 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 {
26800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26801 }
26802 return resultobj;
26803 fail:
26804 return NULL;
26805 }
26806
26807
26808 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj = 0;
26810 wxDateTime *arg1 = (wxDateTime *) 0 ;
26811 wxDateTime *arg2 = 0 ;
26812 bool result;
26813 void *argp1 = 0 ;
26814 int res1 = 0 ;
26815 void *argp2 = 0 ;
26816 int res2 = 0 ;
26817 PyObject * obj0 = 0 ;
26818 PyObject * obj1 = 0 ;
26819 char * kwnames[] = {
26820 (char *) "self",(char *) "datetime", NULL
26821 };
26822
26823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26825 if (!SWIG_IsOK(res1)) {
26826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26827 }
26828 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26829 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26830 if (!SWIG_IsOK(res2)) {
26831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26832 }
26833 if (!argp2) {
26834 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26835 }
26836 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26837 {
26838 PyThreadState* __tstate = wxPyBeginAllowThreads();
26839 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26840 wxPyEndAllowThreads(__tstate);
26841 if (PyErr_Occurred()) SWIG_fail;
26842 }
26843 {
26844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26845 }
26846 return resultobj;
26847 fail:
26848 return NULL;
26849 }
26850
26851
26852 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj = 0;
26854 wxDateTime *arg1 = (wxDateTime *) 0 ;
26855 wxDateTime *arg2 = 0 ;
26856 bool result;
26857 void *argp1 = 0 ;
26858 int res1 = 0 ;
26859 void *argp2 = 0 ;
26860 int res2 = 0 ;
26861 PyObject * obj0 = 0 ;
26862 PyObject * obj1 = 0 ;
26863 char * kwnames[] = {
26864 (char *) "self",(char *) "datetime", NULL
26865 };
26866
26867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26869 if (!SWIG_IsOK(res1)) {
26870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26871 }
26872 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26874 if (!SWIG_IsOK(res2)) {
26875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26876 }
26877 if (!argp2) {
26878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26879 }
26880 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26881 {
26882 PyThreadState* __tstate = wxPyBeginAllowThreads();
26883 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26884 wxPyEndAllowThreads(__tstate);
26885 if (PyErr_Occurred()) SWIG_fail;
26886 }
26887 {
26888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26889 }
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj = 0;
26898 wxDateTime *arg1 = (wxDateTime *) 0 ;
26899 wxDateTime *arg2 = 0 ;
26900 wxDateTime *arg3 = 0 ;
26901 bool result;
26902 void *argp1 = 0 ;
26903 int res1 = 0 ;
26904 void *argp2 = 0 ;
26905 int res2 = 0 ;
26906 void *argp3 = 0 ;
26907 int res3 = 0 ;
26908 PyObject * obj0 = 0 ;
26909 PyObject * obj1 = 0 ;
26910 PyObject * obj2 = 0 ;
26911 char * kwnames[] = {
26912 (char *) "self",(char *) "t1",(char *) "t2", NULL
26913 };
26914
26915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26917 if (!SWIG_IsOK(res1)) {
26918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26919 }
26920 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26921 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26922 if (!SWIG_IsOK(res2)) {
26923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26924 }
26925 if (!argp2) {
26926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26927 }
26928 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26929 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26930 if (!SWIG_IsOK(res3)) {
26931 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26932 }
26933 if (!argp3) {
26934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26935 }
26936 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26937 {
26938 PyThreadState* __tstate = wxPyBeginAllowThreads();
26939 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26940 wxPyEndAllowThreads(__tstate);
26941 if (PyErr_Occurred()) SWIG_fail;
26942 }
26943 {
26944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26945 }
26946 return resultobj;
26947 fail:
26948 return NULL;
26949 }
26950
26951
26952 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26953 PyObject *resultobj = 0;
26954 wxDateTime *arg1 = (wxDateTime *) 0 ;
26955 wxDateTime *arg2 = 0 ;
26956 wxDateTime *arg3 = 0 ;
26957 bool result;
26958 void *argp1 = 0 ;
26959 int res1 = 0 ;
26960 void *argp2 = 0 ;
26961 int res2 = 0 ;
26962 void *argp3 = 0 ;
26963 int res3 = 0 ;
26964 PyObject * obj0 = 0 ;
26965 PyObject * obj1 = 0 ;
26966 PyObject * obj2 = 0 ;
26967 char * kwnames[] = {
26968 (char *) "self",(char *) "t1",(char *) "t2", NULL
26969 };
26970
26971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26973 if (!SWIG_IsOK(res1)) {
26974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26975 }
26976 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26978 if (!SWIG_IsOK(res2)) {
26979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26980 }
26981 if (!argp2) {
26982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26983 }
26984 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26985 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26986 if (!SWIG_IsOK(res3)) {
26987 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26988 }
26989 if (!argp3) {
26990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26991 }
26992 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26993 {
26994 PyThreadState* __tstate = wxPyBeginAllowThreads();
26995 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 {
27000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27001 }
27002 return resultobj;
27003 fail:
27004 return NULL;
27005 }
27006
27007
27008 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27009 PyObject *resultobj = 0;
27010 wxDateTime *arg1 = (wxDateTime *) 0 ;
27011 wxDateTime *arg2 = 0 ;
27012 bool result;
27013 void *argp1 = 0 ;
27014 int res1 = 0 ;
27015 void *argp2 = 0 ;
27016 int res2 = 0 ;
27017 PyObject * obj0 = 0 ;
27018 PyObject * obj1 = 0 ;
27019 char * kwnames[] = {
27020 (char *) "self",(char *) "dt", NULL
27021 };
27022
27023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",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_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27027 }
27028 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27029 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27030 if (!SWIG_IsOK(res2)) {
27031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27032 }
27033 if (!argp2) {
27034 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27035 }
27036 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27037 {
27038 PyThreadState* __tstate = wxPyBeginAllowThreads();
27039 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27040 wxPyEndAllowThreads(__tstate);
27041 if (PyErr_Occurred()) SWIG_fail;
27042 }
27043 {
27044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27045 }
27046 return resultobj;
27047 fail:
27048 return NULL;
27049 }
27050
27051
27052 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27053 PyObject *resultobj = 0;
27054 wxDateTime *arg1 = (wxDateTime *) 0 ;
27055 wxDateTime *arg2 = 0 ;
27056 bool result;
27057 void *argp1 = 0 ;
27058 int res1 = 0 ;
27059 void *argp2 = 0 ;
27060 int res2 = 0 ;
27061 PyObject * obj0 = 0 ;
27062 PyObject * obj1 = 0 ;
27063 char * kwnames[] = {
27064 (char *) "self",(char *) "dt", NULL
27065 };
27066
27067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27069 if (!SWIG_IsOK(res1)) {
27070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27071 }
27072 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27073 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27074 if (!SWIG_IsOK(res2)) {
27075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27076 }
27077 if (!argp2) {
27078 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27079 }
27080 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27081 {
27082 PyThreadState* __tstate = wxPyBeginAllowThreads();
27083 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27084 wxPyEndAllowThreads(__tstate);
27085 if (PyErr_Occurred()) SWIG_fail;
27086 }
27087 {
27088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27089 }
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj = 0;
27098 wxDateTime *arg1 = (wxDateTime *) 0 ;
27099 wxDateTime *arg2 = 0 ;
27100 wxTimeSpan *arg3 = 0 ;
27101 bool result;
27102 void *argp1 = 0 ;
27103 int res1 = 0 ;
27104 void *argp2 = 0 ;
27105 int res2 = 0 ;
27106 void *argp3 = 0 ;
27107 int res3 = 0 ;
27108 PyObject * obj0 = 0 ;
27109 PyObject * obj1 = 0 ;
27110 PyObject * obj2 = 0 ;
27111 char * kwnames[] = {
27112 (char *) "self",(char *) "dt",(char *) "ts", NULL
27113 };
27114
27115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27117 if (!SWIG_IsOK(res1)) {
27118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27119 }
27120 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27121 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27122 if (!SWIG_IsOK(res2)) {
27123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27124 }
27125 if (!argp2) {
27126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27127 }
27128 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27129 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27130 if (!SWIG_IsOK(res3)) {
27131 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27132 }
27133 if (!argp3) {
27134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27135 }
27136 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27137 {
27138 PyThreadState* __tstate = wxPyBeginAllowThreads();
27139 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27140 wxPyEndAllowThreads(__tstate);
27141 if (PyErr_Occurred()) SWIG_fail;
27142 }
27143 {
27144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27145 }
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27153 PyObject *resultobj = 0;
27154 wxDateTime *arg1 = (wxDateTime *) 0 ;
27155 wxTimeSpan *arg2 = 0 ;
27156 wxDateTime *result = 0 ;
27157 void *argp1 = 0 ;
27158 int res1 = 0 ;
27159 void *argp2 = 0 ;
27160 int res2 = 0 ;
27161 PyObject * obj0 = 0 ;
27162 PyObject * obj1 = 0 ;
27163 char * kwnames[] = {
27164 (char *) "self",(char *) "diff", NULL
27165 };
27166
27167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27169 if (!SWIG_IsOK(res1)) {
27170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27171 }
27172 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27174 if (!SWIG_IsOK(res2)) {
27175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27176 }
27177 if (!argp2) {
27178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27179 }
27180 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 {
27184 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27185 result = (wxDateTime *) &_result_ref;
27186 }
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27198 PyObject *resultobj = 0;
27199 wxDateTime *arg1 = (wxDateTime *) 0 ;
27200 wxDateSpan *arg2 = 0 ;
27201 wxDateTime *result = 0 ;
27202 void *argp1 = 0 ;
27203 int res1 = 0 ;
27204 void *argp2 = 0 ;
27205 int res2 = 0 ;
27206 PyObject * obj0 = 0 ;
27207 PyObject * obj1 = 0 ;
27208 char * kwnames[] = {
27209 (char *) "self",(char *) "diff", NULL
27210 };
27211
27212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27214 if (!SWIG_IsOK(res1)) {
27215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27216 }
27217 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27218 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27219 if (!SWIG_IsOK(res2)) {
27220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27221 }
27222 if (!argp2) {
27223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27224 }
27225 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 {
27229 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27230 result = (wxDateTime *) &_result_ref;
27231 }
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27236 return resultobj;
27237 fail:
27238 return NULL;
27239 }
27240
27241
27242 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27243 PyObject *resultobj = 0;
27244 wxDateTime *arg1 = (wxDateTime *) 0 ;
27245 wxTimeSpan *arg2 = 0 ;
27246 wxDateTime *result = 0 ;
27247 void *argp1 = 0 ;
27248 int res1 = 0 ;
27249 void *argp2 = 0 ;
27250 int res2 = 0 ;
27251 PyObject * obj0 = 0 ;
27252 PyObject * obj1 = 0 ;
27253 char * kwnames[] = {
27254 (char *) "self",(char *) "diff", NULL
27255 };
27256
27257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27259 if (!SWIG_IsOK(res1)) {
27260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27261 }
27262 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27263 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27264 if (!SWIG_IsOK(res2)) {
27265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27266 }
27267 if (!argp2) {
27268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27269 }
27270 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 {
27274 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27275 result = (wxDateTime *) &_result_ref;
27276 }
27277 wxPyEndAllowThreads(__tstate);
27278 if (PyErr_Occurred()) SWIG_fail;
27279 }
27280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27281 return resultobj;
27282 fail:
27283 return NULL;
27284 }
27285
27286
27287 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27288 PyObject *resultobj = 0;
27289 wxDateTime *arg1 = (wxDateTime *) 0 ;
27290 wxDateSpan *arg2 = 0 ;
27291 wxDateTime *result = 0 ;
27292 void *argp1 = 0 ;
27293 int res1 = 0 ;
27294 void *argp2 = 0 ;
27295 int res2 = 0 ;
27296 PyObject * obj0 = 0 ;
27297 PyObject * obj1 = 0 ;
27298 char * kwnames[] = {
27299 (char *) "self",(char *) "diff", NULL
27300 };
27301
27302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27304 if (!SWIG_IsOK(res1)) {
27305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27306 }
27307 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27308 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27309 if (!SWIG_IsOK(res2)) {
27310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27311 }
27312 if (!argp2) {
27313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27314 }
27315 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27316 {
27317 PyThreadState* __tstate = wxPyBeginAllowThreads();
27318 {
27319 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27320 result = (wxDateTime *) &_result_ref;
27321 }
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27333 PyObject *resultobj = 0;
27334 wxDateTime *arg1 = (wxDateTime *) 0 ;
27335 wxDateTime *arg2 = 0 ;
27336 wxTimeSpan result;
27337 void *argp1 = 0 ;
27338 int res1 = 0 ;
27339 void *argp2 = 0 ;
27340 int res2 = 0 ;
27341 PyObject * obj0 = 0 ;
27342 PyObject * obj1 = 0 ;
27343 char * kwnames[] = {
27344 (char *) "self",(char *) "dt", NULL
27345 };
27346
27347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27349 if (!SWIG_IsOK(res1)) {
27350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27351 }
27352 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27353 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27354 if (!SWIG_IsOK(res2)) {
27355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27356 }
27357 if (!argp2) {
27358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27359 }
27360 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27361 {
27362 PyThreadState* __tstate = wxPyBeginAllowThreads();
27363 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27368 return resultobj;
27369 fail:
27370 return NULL;
27371 }
27372
27373
27374 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27375 PyObject *resultobj = 0;
27376 wxDateTime *arg1 = (wxDateTime *) 0 ;
27377 wxTimeSpan *arg2 = 0 ;
27378 wxDateTime *result = 0 ;
27379 void *argp1 = 0 ;
27380 int res1 = 0 ;
27381 void *argp2 = 0 ;
27382 int res2 = 0 ;
27383
27384 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27386 if (!SWIG_IsOK(res1)) {
27387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27388 }
27389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27390 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27391 if (!SWIG_IsOK(res2)) {
27392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27393 }
27394 if (!argp2) {
27395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27396 }
27397 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 {
27401 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27402 result = (wxDateTime *) &_result_ref;
27403 }
27404 wxPyEndAllowThreads(__tstate);
27405 if (PyErr_Occurred()) SWIG_fail;
27406 }
27407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27415 PyObject *resultobj = 0;
27416 wxDateTime *arg1 = (wxDateTime *) 0 ;
27417 wxDateSpan *arg2 = 0 ;
27418 wxDateTime *result = 0 ;
27419 void *argp1 = 0 ;
27420 int res1 = 0 ;
27421 void *argp2 = 0 ;
27422 int res2 = 0 ;
27423
27424 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27426 if (!SWIG_IsOK(res1)) {
27427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27428 }
27429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27430 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27431 if (!SWIG_IsOK(res2)) {
27432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27433 }
27434 if (!argp2) {
27435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27436 }
27437 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27438 {
27439 PyThreadState* __tstate = wxPyBeginAllowThreads();
27440 {
27441 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27442 result = (wxDateTime *) &_result_ref;
27443 }
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27455 int argc;
27456 PyObject *argv[3];
27457
27458 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27459 --argc;
27460 if (argc == 2) {
27461 int _v = 0;
27462 {
27463 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27464 _v = SWIG_CheckState(res);
27465 }
27466 if (!_v) goto check_1;
27467 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27468 }
27469 check_1:
27470
27471 if (argc == 2) {
27472 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27473 }
27474
27475 fail:
27476 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27477 return NULL;
27478 }
27479
27480
27481 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27482 PyObject *resultobj = 0;
27483 wxDateTime *arg1 = (wxDateTime *) 0 ;
27484 wxTimeSpan *arg2 = 0 ;
27485 wxDateTime *result = 0 ;
27486 void *argp1 = 0 ;
27487 int res1 = 0 ;
27488 void *argp2 = 0 ;
27489 int res2 = 0 ;
27490
27491 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27493 if (!SWIG_IsOK(res1)) {
27494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27495 }
27496 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27497 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27498 if (!SWIG_IsOK(res2)) {
27499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27500 }
27501 if (!argp2) {
27502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27503 }
27504 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 {
27508 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27509 result = (wxDateTime *) &_result_ref;
27510 }
27511 wxPyEndAllowThreads(__tstate);
27512 if (PyErr_Occurred()) SWIG_fail;
27513 }
27514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27515 return resultobj;
27516 fail:
27517 return NULL;
27518 }
27519
27520
27521 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27522 PyObject *resultobj = 0;
27523 wxDateTime *arg1 = (wxDateTime *) 0 ;
27524 wxDateSpan *arg2 = 0 ;
27525 wxDateTime *result = 0 ;
27526 void *argp1 = 0 ;
27527 int res1 = 0 ;
27528 void *argp2 = 0 ;
27529 int res2 = 0 ;
27530
27531 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27533 if (!SWIG_IsOK(res1)) {
27534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27535 }
27536 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27537 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27538 if (!SWIG_IsOK(res2)) {
27539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27540 }
27541 if (!argp2) {
27542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27543 }
27544 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27545 {
27546 PyThreadState* __tstate = wxPyBeginAllowThreads();
27547 {
27548 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27549 result = (wxDateTime *) &_result_ref;
27550 }
27551 wxPyEndAllowThreads(__tstate);
27552 if (PyErr_Occurred()) SWIG_fail;
27553 }
27554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27555 return resultobj;
27556 fail:
27557 return NULL;
27558 }
27559
27560
27561 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27562 int argc;
27563 PyObject *argv[3];
27564
27565 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27566 --argc;
27567 if (argc == 2) {
27568 int _v = 0;
27569 {
27570 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27571 _v = SWIG_CheckState(res);
27572 }
27573 if (!_v) goto check_1;
27574 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27575 }
27576 check_1:
27577
27578 if (argc == 2) {
27579 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27580 }
27581
27582 fail:
27583 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27584 return NULL;
27585 }
27586
27587
27588 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27589 PyObject *resultobj = 0;
27590 wxDateTime *arg1 = (wxDateTime *) 0 ;
27591 wxTimeSpan *arg2 = 0 ;
27592 wxDateTime result;
27593 void *argp1 = 0 ;
27594 int res1 = 0 ;
27595 void *argp2 = 0 ;
27596 int res2 = 0 ;
27597
27598 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27600 if (!SWIG_IsOK(res1)) {
27601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27602 }
27603 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27604 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27605 if (!SWIG_IsOK(res2)) {
27606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27607 }
27608 if (!argp2) {
27609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27610 }
27611 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27612 {
27613 PyThreadState* __tstate = wxPyBeginAllowThreads();
27614 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27615 wxPyEndAllowThreads(__tstate);
27616 if (PyErr_Occurred()) SWIG_fail;
27617 }
27618 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27619 return resultobj;
27620 fail:
27621 return NULL;
27622 }
27623
27624
27625 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27626 PyObject *resultobj = 0;
27627 wxDateTime *arg1 = (wxDateTime *) 0 ;
27628 wxDateSpan *arg2 = 0 ;
27629 wxDateTime result;
27630 void *argp1 = 0 ;
27631 int res1 = 0 ;
27632 void *argp2 = 0 ;
27633 int res2 = 0 ;
27634
27635 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27637 if (!SWIG_IsOK(res1)) {
27638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27639 }
27640 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27641 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27642 if (!SWIG_IsOK(res2)) {
27643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27644 }
27645 if (!argp2) {
27646 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27647 }
27648 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27663 int argc;
27664 PyObject *argv[3];
27665
27666 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27667 --argc;
27668 if (argc == 2) {
27669 int _v = 0;
27670 {
27671 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27672 _v = SWIG_CheckState(res);
27673 }
27674 if (!_v) goto check_1;
27675 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27676 }
27677 check_1:
27678
27679 if (argc == 2) {
27680 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27681 }
27682
27683 fail:
27684 Py_INCREF(Py_NotImplemented);
27685 return Py_NotImplemented;
27686 }
27687
27688
27689 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27690 PyObject *resultobj = 0;
27691 wxDateTime *arg1 = (wxDateTime *) 0 ;
27692 wxDateTime *arg2 = 0 ;
27693 wxTimeSpan result;
27694 void *argp1 = 0 ;
27695 int res1 = 0 ;
27696 void *argp2 = 0 ;
27697 int res2 = 0 ;
27698
27699 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27701 if (!SWIG_IsOK(res1)) {
27702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27703 }
27704 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27705 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27706 if (!SWIG_IsOK(res2)) {
27707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27708 }
27709 if (!argp2) {
27710 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27711 }
27712 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27716 wxPyEndAllowThreads(__tstate);
27717 if (PyErr_Occurred()) SWIG_fail;
27718 }
27719 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27720 return resultobj;
27721 fail:
27722 return NULL;
27723 }
27724
27725
27726 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27727 PyObject *resultobj = 0;
27728 wxDateTime *arg1 = (wxDateTime *) 0 ;
27729 wxTimeSpan *arg2 = 0 ;
27730 wxDateTime result;
27731 void *argp1 = 0 ;
27732 int res1 = 0 ;
27733 void *argp2 = 0 ;
27734 int res2 = 0 ;
27735
27736 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27738 if (!SWIG_IsOK(res1)) {
27739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27740 }
27741 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27742 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27743 if (!SWIG_IsOK(res2)) {
27744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27745 }
27746 if (!argp2) {
27747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27748 }
27749 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27750 {
27751 PyThreadState* __tstate = wxPyBeginAllowThreads();
27752 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27753 wxPyEndAllowThreads(__tstate);
27754 if (PyErr_Occurred()) SWIG_fail;
27755 }
27756 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27764 PyObject *resultobj = 0;
27765 wxDateTime *arg1 = (wxDateTime *) 0 ;
27766 wxDateSpan *arg2 = 0 ;
27767 wxDateTime result;
27768 void *argp1 = 0 ;
27769 int res1 = 0 ;
27770 void *argp2 = 0 ;
27771 int res2 = 0 ;
27772
27773 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27775 if (!SWIG_IsOK(res1)) {
27776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27777 }
27778 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27779 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27780 if (!SWIG_IsOK(res2)) {
27781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27782 }
27783 if (!argp2) {
27784 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27785 }
27786 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27787 {
27788 PyThreadState* __tstate = wxPyBeginAllowThreads();
27789 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27801 int argc;
27802 PyObject *argv[3];
27803
27804 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27805 --argc;
27806 if (argc == 2) {
27807 int _v = 0;
27808 {
27809 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27810 _v = SWIG_CheckState(res);
27811 }
27812 if (!_v) goto check_1;
27813 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27814 }
27815 check_1:
27816
27817 if (argc == 2) {
27818 int _v = 0;
27819 {
27820 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27821 _v = SWIG_CheckState(res);
27822 }
27823 if (!_v) goto check_2;
27824 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27825 }
27826 check_2:
27827
27828 if (argc == 2) {
27829 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27830 }
27831
27832 fail:
27833 Py_INCREF(Py_NotImplemented);
27834 return Py_NotImplemented;
27835 }
27836
27837
27838 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27839 PyObject *resultobj = 0;
27840 wxDateTime *arg1 = (wxDateTime *) 0 ;
27841 wxDateTime *arg2 = (wxDateTime *) 0 ;
27842 bool result;
27843 void *argp1 = 0 ;
27844 int res1 = 0 ;
27845 void *argp2 = 0 ;
27846 int res2 = 0 ;
27847 PyObject * obj0 = 0 ;
27848 PyObject * obj1 = 0 ;
27849 char * kwnames[] = {
27850 (char *) "self",(char *) "other", NULL
27851 };
27852
27853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27855 if (!SWIG_IsOK(res1)) {
27856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27857 }
27858 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27859 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27860 if (!SWIG_IsOK(res2)) {
27861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27862 }
27863 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27864 {
27865 PyThreadState* __tstate = wxPyBeginAllowThreads();
27866 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27867 wxPyEndAllowThreads(__tstate);
27868 if (PyErr_Occurred()) SWIG_fail;
27869 }
27870 {
27871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27872 }
27873 return resultobj;
27874 fail:
27875 return NULL;
27876 }
27877
27878
27879 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27880 PyObject *resultobj = 0;
27881 wxDateTime *arg1 = (wxDateTime *) 0 ;
27882 wxDateTime *arg2 = (wxDateTime *) 0 ;
27883 bool result;
27884 void *argp1 = 0 ;
27885 int res1 = 0 ;
27886 void *argp2 = 0 ;
27887 int res2 = 0 ;
27888 PyObject * obj0 = 0 ;
27889 PyObject * obj1 = 0 ;
27890 char * kwnames[] = {
27891 (char *) "self",(char *) "other", NULL
27892 };
27893
27894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27898 }
27899 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27900 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27901 if (!SWIG_IsOK(res2)) {
27902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27903 }
27904 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 {
27912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27913 }
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27921 PyObject *resultobj = 0;
27922 wxDateTime *arg1 = (wxDateTime *) 0 ;
27923 wxDateTime *arg2 = (wxDateTime *) 0 ;
27924 bool result;
27925 void *argp1 = 0 ;
27926 int res1 = 0 ;
27927 void *argp2 = 0 ;
27928 int res2 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 char * kwnames[] = {
27932 (char *) "self",(char *) "other", NULL
27933 };
27934
27935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27939 }
27940 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27942 if (!SWIG_IsOK(res2)) {
27943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27944 }
27945 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj = 0;
27963 wxDateTime *arg1 = (wxDateTime *) 0 ;
27964 wxDateTime *arg2 = (wxDateTime *) 0 ;
27965 bool result;
27966 void *argp1 = 0 ;
27967 int res1 = 0 ;
27968 void *argp2 = 0 ;
27969 int res2 = 0 ;
27970 PyObject * obj0 = 0 ;
27971 PyObject * obj1 = 0 ;
27972 char * kwnames[] = {
27973 (char *) "self",(char *) "other", NULL
27974 };
27975
27976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27978 if (!SWIG_IsOK(res1)) {
27979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27980 }
27981 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27983 if (!SWIG_IsOK(res2)) {
27984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27985 }
27986 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27987 {
27988 PyThreadState* __tstate = wxPyBeginAllowThreads();
27989 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27990 wxPyEndAllowThreads(__tstate);
27991 if (PyErr_Occurred()) SWIG_fail;
27992 }
27993 {
27994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27995 }
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28003 PyObject *resultobj = 0;
28004 wxDateTime *arg1 = (wxDateTime *) 0 ;
28005 wxDateTime *arg2 = (wxDateTime *) 0 ;
28006 bool result;
28007 void *argp1 = 0 ;
28008 int res1 = 0 ;
28009 void *argp2 = 0 ;
28010 int res2 = 0 ;
28011 PyObject * obj0 = 0 ;
28012 PyObject * obj1 = 0 ;
28013 char * kwnames[] = {
28014 (char *) "self",(char *) "other", NULL
28015 };
28016
28017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28019 if (!SWIG_IsOK(res1)) {
28020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28021 }
28022 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28023 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28024 if (!SWIG_IsOK(res2)) {
28025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28026 }
28027 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28028 {
28029 PyThreadState* __tstate = wxPyBeginAllowThreads();
28030 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28031 wxPyEndAllowThreads(__tstate);
28032 if (PyErr_Occurred()) SWIG_fail;
28033 }
28034 {
28035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28036 }
28037 return resultobj;
28038 fail:
28039 return NULL;
28040 }
28041
28042
28043 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28044 PyObject *resultobj = 0;
28045 wxDateTime *arg1 = (wxDateTime *) 0 ;
28046 wxDateTime *arg2 = (wxDateTime *) 0 ;
28047 bool result;
28048 void *argp1 = 0 ;
28049 int res1 = 0 ;
28050 void *argp2 = 0 ;
28051 int res2 = 0 ;
28052 PyObject * obj0 = 0 ;
28053 PyObject * obj1 = 0 ;
28054 char * kwnames[] = {
28055 (char *) "self",(char *) "other", NULL
28056 };
28057
28058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28060 if (!SWIG_IsOK(res1)) {
28061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28062 }
28063 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28065 if (!SWIG_IsOK(res2)) {
28066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28067 }
28068 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28069 {
28070 PyThreadState* __tstate = wxPyBeginAllowThreads();
28071 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28072 wxPyEndAllowThreads(__tstate);
28073 if (PyErr_Occurred()) SWIG_fail;
28074 }
28075 {
28076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28077 }
28078 return resultobj;
28079 fail:
28080 return NULL;
28081 }
28082
28083
28084 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28085 PyObject *resultobj = 0;
28086 wxDateTime *arg1 = (wxDateTime *) 0 ;
28087 wxString *arg2 = 0 ;
28088 int result;
28089 void *argp1 = 0 ;
28090 int res1 = 0 ;
28091 bool temp2 = false ;
28092 PyObject * obj0 = 0 ;
28093 PyObject * obj1 = 0 ;
28094 char * kwnames[] = {
28095 (char *) "self",(char *) "date", NULL
28096 };
28097
28098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28100 if (!SWIG_IsOK(res1)) {
28101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28102 }
28103 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28104 {
28105 arg2 = wxString_in_helper(obj1);
28106 if (arg2 == NULL) SWIG_fail;
28107 temp2 = true;
28108 }
28109 {
28110 PyThreadState* __tstate = wxPyBeginAllowThreads();
28111 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28112 wxPyEndAllowThreads(__tstate);
28113 if (PyErr_Occurred()) SWIG_fail;
28114 }
28115 resultobj = SWIG_From_int(static_cast< int >(result));
28116 {
28117 if (temp2)
28118 delete arg2;
28119 }
28120 return resultobj;
28121 fail:
28122 {
28123 if (temp2)
28124 delete arg2;
28125 }
28126 return NULL;
28127 }
28128
28129
28130 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28131 PyObject *resultobj = 0;
28132 wxDateTime *arg1 = (wxDateTime *) 0 ;
28133 wxString *arg2 = 0 ;
28134 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28135 wxString *arg3 = (wxString *) &arg3_defvalue ;
28136 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28137 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28138 int result;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 bool temp2 = false ;
28142 bool temp3 = false ;
28143 void *argp4 = 0 ;
28144 int res4 = 0 ;
28145 PyObject * obj0 = 0 ;
28146 PyObject * obj1 = 0 ;
28147 PyObject * obj2 = 0 ;
28148 PyObject * obj3 = 0 ;
28149 char * kwnames[] = {
28150 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28151 };
28152
28153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28155 if (!SWIG_IsOK(res1)) {
28156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28157 }
28158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28159 {
28160 arg2 = wxString_in_helper(obj1);
28161 if (arg2 == NULL) SWIG_fail;
28162 temp2 = true;
28163 }
28164 if (obj2) {
28165 {
28166 arg3 = wxString_in_helper(obj2);
28167 if (arg3 == NULL) SWIG_fail;
28168 temp3 = true;
28169 }
28170 }
28171 if (obj3) {
28172 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28173 if (!SWIG_IsOK(res4)) {
28174 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28175 }
28176 if (!argp4) {
28177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28178 }
28179 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28180 }
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 resultobj = SWIG_From_int(static_cast< int >(result));
28188 {
28189 if (temp2)
28190 delete arg2;
28191 }
28192 {
28193 if (temp3)
28194 delete arg3;
28195 }
28196 return resultobj;
28197 fail:
28198 {
28199 if (temp2)
28200 delete arg2;
28201 }
28202 {
28203 if (temp3)
28204 delete arg3;
28205 }
28206 return NULL;
28207 }
28208
28209
28210 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28211 PyObject *resultobj = 0;
28212 wxDateTime *arg1 = (wxDateTime *) 0 ;
28213 wxString *arg2 = 0 ;
28214 int result;
28215 void *argp1 = 0 ;
28216 int res1 = 0 ;
28217 bool temp2 = false ;
28218 PyObject * obj0 = 0 ;
28219 PyObject * obj1 = 0 ;
28220 char * kwnames[] = {
28221 (char *) "self",(char *) "datetime", NULL
28222 };
28223
28224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28226 if (!SWIG_IsOK(res1)) {
28227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28228 }
28229 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28230 {
28231 arg2 = wxString_in_helper(obj1);
28232 if (arg2 == NULL) SWIG_fail;
28233 temp2 = true;
28234 }
28235 {
28236 PyThreadState* __tstate = wxPyBeginAllowThreads();
28237 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28238 wxPyEndAllowThreads(__tstate);
28239 if (PyErr_Occurred()) SWIG_fail;
28240 }
28241 resultobj = SWIG_From_int(static_cast< int >(result));
28242 {
28243 if (temp2)
28244 delete arg2;
28245 }
28246 return resultobj;
28247 fail:
28248 {
28249 if (temp2)
28250 delete arg2;
28251 }
28252 return NULL;
28253 }
28254
28255
28256 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28257 PyObject *resultobj = 0;
28258 wxDateTime *arg1 = (wxDateTime *) 0 ;
28259 wxString *arg2 = 0 ;
28260 int result;
28261 void *argp1 = 0 ;
28262 int res1 = 0 ;
28263 bool temp2 = false ;
28264 PyObject * obj0 = 0 ;
28265 PyObject * obj1 = 0 ;
28266 char * kwnames[] = {
28267 (char *) "self",(char *) "date", NULL
28268 };
28269
28270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28272 if (!SWIG_IsOK(res1)) {
28273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28274 }
28275 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28276 {
28277 arg2 = wxString_in_helper(obj1);
28278 if (arg2 == NULL) SWIG_fail;
28279 temp2 = true;
28280 }
28281 {
28282 PyThreadState* __tstate = wxPyBeginAllowThreads();
28283 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28284 wxPyEndAllowThreads(__tstate);
28285 if (PyErr_Occurred()) SWIG_fail;
28286 }
28287 resultobj = SWIG_From_int(static_cast< int >(result));
28288 {
28289 if (temp2)
28290 delete arg2;
28291 }
28292 return resultobj;
28293 fail:
28294 {
28295 if (temp2)
28296 delete arg2;
28297 }
28298 return NULL;
28299 }
28300
28301
28302 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28303 PyObject *resultobj = 0;
28304 wxDateTime *arg1 = (wxDateTime *) 0 ;
28305 wxString *arg2 = 0 ;
28306 int result;
28307 void *argp1 = 0 ;
28308 int res1 = 0 ;
28309 bool temp2 = false ;
28310 PyObject * obj0 = 0 ;
28311 PyObject * obj1 = 0 ;
28312 char * kwnames[] = {
28313 (char *) "self",(char *) "time", NULL
28314 };
28315
28316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28318 if (!SWIG_IsOK(res1)) {
28319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28320 }
28321 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28322 {
28323 arg2 = wxString_in_helper(obj1);
28324 if (arg2 == NULL) SWIG_fail;
28325 temp2 = true;
28326 }
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28330 wxPyEndAllowThreads(__tstate);
28331 if (PyErr_Occurred()) SWIG_fail;
28332 }
28333 resultobj = SWIG_From_int(static_cast< int >(result));
28334 {
28335 if (temp2)
28336 delete arg2;
28337 }
28338 return resultobj;
28339 fail:
28340 {
28341 if (temp2)
28342 delete arg2;
28343 }
28344 return NULL;
28345 }
28346
28347
28348 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj = 0;
28350 wxDateTime *arg1 = (wxDateTime *) 0 ;
28351 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28352 wxString *arg2 = (wxString *) &arg2_defvalue ;
28353 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28354 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28355 wxString result;
28356 void *argp1 = 0 ;
28357 int res1 = 0 ;
28358 bool temp2 = false ;
28359 bool temp3 = false ;
28360 PyObject * obj0 = 0 ;
28361 PyObject * obj1 = 0 ;
28362 PyObject * obj2 = 0 ;
28363 char * kwnames[] = {
28364 (char *) "self",(char *) "format",(char *) "tz", NULL
28365 };
28366
28367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28369 if (!SWIG_IsOK(res1)) {
28370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28371 }
28372 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28373 if (obj1) {
28374 {
28375 arg2 = wxString_in_helper(obj1);
28376 if (arg2 == NULL) SWIG_fail;
28377 temp2 = true;
28378 }
28379 }
28380 if (obj2) {
28381 {
28382 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28383 temp3 = true;
28384 }
28385 }
28386 {
28387 PyThreadState* __tstate = wxPyBeginAllowThreads();
28388 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 {
28393 #if wxUSE_UNICODE
28394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28395 #else
28396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28397 #endif
28398 }
28399 {
28400 if (temp2)
28401 delete arg2;
28402 }
28403 {
28404 if (temp3) delete arg3;
28405 }
28406 return resultobj;
28407 fail:
28408 {
28409 if (temp2)
28410 delete arg2;
28411 }
28412 {
28413 if (temp3) delete arg3;
28414 }
28415 return NULL;
28416 }
28417
28418
28419 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28420 PyObject *resultobj = 0;
28421 wxDateTime *arg1 = (wxDateTime *) 0 ;
28422 wxString result;
28423 void *argp1 = 0 ;
28424 int res1 = 0 ;
28425 PyObject *swig_obj[1] ;
28426
28427 if (!args) SWIG_fail;
28428 swig_obj[0] = args;
28429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28430 if (!SWIG_IsOK(res1)) {
28431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28432 }
28433 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 result = ((wxDateTime const *)arg1)->FormatDate();
28437 wxPyEndAllowThreads(__tstate);
28438 if (PyErr_Occurred()) SWIG_fail;
28439 }
28440 {
28441 #if wxUSE_UNICODE
28442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28443 #else
28444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28445 #endif
28446 }
28447 return resultobj;
28448 fail:
28449 return NULL;
28450 }
28451
28452
28453 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28454 PyObject *resultobj = 0;
28455 wxDateTime *arg1 = (wxDateTime *) 0 ;
28456 wxString result;
28457 void *argp1 = 0 ;
28458 int res1 = 0 ;
28459 PyObject *swig_obj[1] ;
28460
28461 if (!args) SWIG_fail;
28462 swig_obj[0] = args;
28463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28464 if (!SWIG_IsOK(res1)) {
28465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28466 }
28467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28468 {
28469 PyThreadState* __tstate = wxPyBeginAllowThreads();
28470 result = ((wxDateTime const *)arg1)->FormatTime();
28471 wxPyEndAllowThreads(__tstate);
28472 if (PyErr_Occurred()) SWIG_fail;
28473 }
28474 {
28475 #if wxUSE_UNICODE
28476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28477 #else
28478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28479 #endif
28480 }
28481 return resultobj;
28482 fail:
28483 return NULL;
28484 }
28485
28486
28487 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28488 PyObject *resultobj = 0;
28489 wxDateTime *arg1 = (wxDateTime *) 0 ;
28490 wxString result;
28491 void *argp1 = 0 ;
28492 int res1 = 0 ;
28493 PyObject *swig_obj[1] ;
28494
28495 if (!args) SWIG_fail;
28496 swig_obj[0] = args;
28497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28498 if (!SWIG_IsOK(res1)) {
28499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28500 }
28501 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28502 {
28503 PyThreadState* __tstate = wxPyBeginAllowThreads();
28504 result = ((wxDateTime const *)arg1)->FormatISODate();
28505 wxPyEndAllowThreads(__tstate);
28506 if (PyErr_Occurred()) SWIG_fail;
28507 }
28508 {
28509 #if wxUSE_UNICODE
28510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28511 #else
28512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28513 #endif
28514 }
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28522 PyObject *resultobj = 0;
28523 wxDateTime *arg1 = (wxDateTime *) 0 ;
28524 wxString result;
28525 void *argp1 = 0 ;
28526 int res1 = 0 ;
28527 PyObject *swig_obj[1] ;
28528
28529 if (!args) SWIG_fail;
28530 swig_obj[0] = args;
28531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28532 if (!SWIG_IsOK(res1)) {
28533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28534 }
28535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28536 {
28537 PyThreadState* __tstate = wxPyBeginAllowThreads();
28538 result = ((wxDateTime const *)arg1)->FormatISOTime();
28539 wxPyEndAllowThreads(__tstate);
28540 if (PyErr_Occurred()) SWIG_fail;
28541 }
28542 {
28543 #if wxUSE_UNICODE
28544 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28545 #else
28546 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28547 #endif
28548 }
28549 return resultobj;
28550 fail:
28551 return NULL;
28552 }
28553
28554
28555 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28556 PyObject *obj;
28557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28558 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28559 return SWIG_Py_Void();
28560 }
28561
28562 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28563 return SWIG_Python_InitShadowInstance(args);
28564 }
28565
28566 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj = 0;
28568 long arg1 ;
28569 wxTimeSpan result;
28570 long val1 ;
28571 int ecode1 = 0 ;
28572 PyObject * obj0 = 0 ;
28573 char * kwnames[] = {
28574 (char *) "ms", NULL
28575 };
28576
28577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28578 ecode1 = SWIG_AsVal_long(obj0, &val1);
28579 if (!SWIG_IsOK(ecode1)) {
28580 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28581 }
28582 arg1 = static_cast< long >(val1);
28583 {
28584 PyThreadState* __tstate = wxPyBeginAllowThreads();
28585 result = wxTimeSpan::Milliseconds(arg1);
28586 wxPyEndAllowThreads(__tstate);
28587 if (PyErr_Occurred()) SWIG_fail;
28588 }
28589 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28590 return resultobj;
28591 fail:
28592 return NULL;
28593 }
28594
28595
28596 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28597 PyObject *resultobj = 0;
28598 wxTimeSpan result;
28599
28600 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = wxTimeSpan::Millisecond();
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj = 0;
28616 long arg1 ;
28617 wxTimeSpan result;
28618 long val1 ;
28619 int ecode1 = 0 ;
28620 PyObject * obj0 = 0 ;
28621 char * kwnames[] = {
28622 (char *) "sec", NULL
28623 };
28624
28625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28626 ecode1 = SWIG_AsVal_long(obj0, &val1);
28627 if (!SWIG_IsOK(ecode1)) {
28628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28629 }
28630 arg1 = static_cast< long >(val1);
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = wxTimeSpan::Seconds(arg1);
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxTimeSpan result;
28647
28648 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 result = wxTimeSpan::Second();
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj = 0;
28664 long arg1 ;
28665 wxTimeSpan result;
28666 long val1 ;
28667 int ecode1 = 0 ;
28668 PyObject * obj0 = 0 ;
28669 char * kwnames[] = {
28670 (char *) "min", NULL
28671 };
28672
28673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28674 ecode1 = SWIG_AsVal_long(obj0, &val1);
28675 if (!SWIG_IsOK(ecode1)) {
28676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28677 }
28678 arg1 = static_cast< long >(val1);
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = wxTimeSpan::Minutes(arg1);
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28693 PyObject *resultobj = 0;
28694 wxTimeSpan result;
28695
28696 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28697 {
28698 PyThreadState* __tstate = wxPyBeginAllowThreads();
28699 result = wxTimeSpan::Minute();
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj = 0;
28712 long arg1 ;
28713 wxTimeSpan result;
28714 long val1 ;
28715 int ecode1 = 0 ;
28716 PyObject * obj0 = 0 ;
28717 char * kwnames[] = {
28718 (char *) "hours", NULL
28719 };
28720
28721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28722 ecode1 = SWIG_AsVal_long(obj0, &val1);
28723 if (!SWIG_IsOK(ecode1)) {
28724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28725 }
28726 arg1 = static_cast< long >(val1);
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = wxTimeSpan::Hours(arg1);
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741 PyObject *resultobj = 0;
28742 wxTimeSpan result;
28743
28744 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = wxTimeSpan::Hour();
28748 wxPyEndAllowThreads(__tstate);
28749 if (PyErr_Occurred()) SWIG_fail;
28750 }
28751 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj = 0;
28760 long arg1 ;
28761 wxTimeSpan result;
28762 long val1 ;
28763 int ecode1 = 0 ;
28764 PyObject * obj0 = 0 ;
28765 char * kwnames[] = {
28766 (char *) "days", NULL
28767 };
28768
28769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28770 ecode1 = SWIG_AsVal_long(obj0, &val1);
28771 if (!SWIG_IsOK(ecode1)) {
28772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28773 }
28774 arg1 = static_cast< long >(val1);
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = wxTimeSpan::Days(arg1);
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28782 return resultobj;
28783 fail:
28784 return NULL;
28785 }
28786
28787
28788 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28789 PyObject *resultobj = 0;
28790 wxTimeSpan result;
28791
28792 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = wxTimeSpan::Day();
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28807 PyObject *resultobj = 0;
28808 long arg1 ;
28809 wxTimeSpan result;
28810 long val1 ;
28811 int ecode1 = 0 ;
28812 PyObject * obj0 = 0 ;
28813 char * kwnames[] = {
28814 (char *) "days", NULL
28815 };
28816
28817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28818 ecode1 = SWIG_AsVal_long(obj0, &val1);
28819 if (!SWIG_IsOK(ecode1)) {
28820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28821 }
28822 arg1 = static_cast< long >(val1);
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = wxTimeSpan::Weeks(arg1);
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28837 PyObject *resultobj = 0;
28838 wxTimeSpan result;
28839
28840 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28841 {
28842 PyThreadState* __tstate = wxPyBeginAllowThreads();
28843 result = wxTimeSpan::Week();
28844 wxPyEndAllowThreads(__tstate);
28845 if (PyErr_Occurred()) SWIG_fail;
28846 }
28847 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28855 PyObject *resultobj = 0;
28856 long arg1 = (long) 0 ;
28857 long arg2 = (long) 0 ;
28858 long arg3 = (long) 0 ;
28859 long arg4 = (long) 0 ;
28860 wxTimeSpan *result = 0 ;
28861 long val1 ;
28862 int ecode1 = 0 ;
28863 long val2 ;
28864 int ecode2 = 0 ;
28865 long val3 ;
28866 int ecode3 = 0 ;
28867 long val4 ;
28868 int ecode4 = 0 ;
28869 PyObject * obj0 = 0 ;
28870 PyObject * obj1 = 0 ;
28871 PyObject * obj2 = 0 ;
28872 PyObject * obj3 = 0 ;
28873 char * kwnames[] = {
28874 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28875 };
28876
28877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28878 if (obj0) {
28879 ecode1 = SWIG_AsVal_long(obj0, &val1);
28880 if (!SWIG_IsOK(ecode1)) {
28881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28882 }
28883 arg1 = static_cast< long >(val1);
28884 }
28885 if (obj1) {
28886 ecode2 = SWIG_AsVal_long(obj1, &val2);
28887 if (!SWIG_IsOK(ecode2)) {
28888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28889 }
28890 arg2 = static_cast< long >(val2);
28891 }
28892 if (obj2) {
28893 ecode3 = SWIG_AsVal_long(obj2, &val3);
28894 if (!SWIG_IsOK(ecode3)) {
28895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28896 }
28897 arg3 = static_cast< long >(val3);
28898 }
28899 if (obj3) {
28900 ecode4 = SWIG_AsVal_long(obj3, &val4);
28901 if (!SWIG_IsOK(ecode4)) {
28902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28903 }
28904 arg4 = static_cast< long >(val4);
28905 }
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28913 return resultobj;
28914 fail:
28915 return NULL;
28916 }
28917
28918
28919 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28920 PyObject *resultobj = 0;
28921 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28922 void *argp1 = 0 ;
28923 int res1 = 0 ;
28924 PyObject *swig_obj[1] ;
28925
28926 if (!args) SWIG_fail;
28927 swig_obj[0] = args;
28928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28929 if (!SWIG_IsOK(res1)) {
28930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28931 }
28932 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28933 {
28934 PyThreadState* __tstate = wxPyBeginAllowThreads();
28935 delete arg1;
28936
28937 wxPyEndAllowThreads(__tstate);
28938 if (PyErr_Occurred()) SWIG_fail;
28939 }
28940 resultobj = SWIG_Py_Void();
28941 return resultobj;
28942 fail:
28943 return NULL;
28944 }
28945
28946
28947 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28948 PyObject *resultobj = 0;
28949 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28950 wxTimeSpan *arg2 = 0 ;
28951 wxTimeSpan *result = 0 ;
28952 void *argp1 = 0 ;
28953 int res1 = 0 ;
28954 void *argp2 = 0 ;
28955 int res2 = 0 ;
28956 PyObject * obj0 = 0 ;
28957 PyObject * obj1 = 0 ;
28958 char * kwnames[] = {
28959 (char *) "self",(char *) "diff", NULL
28960 };
28961
28962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28964 if (!SWIG_IsOK(res1)) {
28965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28966 }
28967 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28969 if (!SWIG_IsOK(res2)) {
28970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28971 }
28972 if (!argp2) {
28973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28974 }
28975 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28976 {
28977 PyThreadState* __tstate = wxPyBeginAllowThreads();
28978 {
28979 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28980 result = (wxTimeSpan *) &_result_ref;
28981 }
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28986 return resultobj;
28987 fail:
28988 return NULL;
28989 }
28990
28991
28992 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28993 PyObject *resultobj = 0;
28994 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28995 wxTimeSpan *arg2 = 0 ;
28996 wxTimeSpan *result = 0 ;
28997 void *argp1 = 0 ;
28998 int res1 = 0 ;
28999 void *argp2 = 0 ;
29000 int res2 = 0 ;
29001 PyObject * obj0 = 0 ;
29002 PyObject * obj1 = 0 ;
29003 char * kwnames[] = {
29004 (char *) "self",(char *) "diff", NULL
29005 };
29006
29007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29009 if (!SWIG_IsOK(res1)) {
29010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29011 }
29012 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29013 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29014 if (!SWIG_IsOK(res2)) {
29015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29016 }
29017 if (!argp2) {
29018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29019 }
29020 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 {
29024 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29025 result = (wxTimeSpan *) &_result_ref;
29026 }
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29038 PyObject *resultobj = 0;
29039 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29040 int arg2 ;
29041 wxTimeSpan *result = 0 ;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 int val2 ;
29045 int ecode2 = 0 ;
29046 PyObject * obj0 = 0 ;
29047 PyObject * obj1 = 0 ;
29048 char * kwnames[] = {
29049 (char *) "self",(char *) "n", NULL
29050 };
29051
29052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29054 if (!SWIG_IsOK(res1)) {
29055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29056 }
29057 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29058 ecode2 = SWIG_AsVal_int(obj1, &val2);
29059 if (!SWIG_IsOK(ecode2)) {
29060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29061 }
29062 arg2 = static_cast< int >(val2);
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 {
29066 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29067 result = (wxTimeSpan *) &_result_ref;
29068 }
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29080 PyObject *resultobj = 0;
29081 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29082 wxTimeSpan *result = 0 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 PyObject *swig_obj[1] ;
29086
29087 if (!args) SWIG_fail;
29088 swig_obj[0] = args;
29089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29090 if (!SWIG_IsOK(res1)) {
29091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29092 }
29093 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 {
29097 wxTimeSpan &_result_ref = (arg1)->Neg();
29098 result = (wxTimeSpan *) &_result_ref;
29099 }
29100 wxPyEndAllowThreads(__tstate);
29101 if (PyErr_Occurred()) SWIG_fail;
29102 }
29103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29104 return resultobj;
29105 fail:
29106 return NULL;
29107 }
29108
29109
29110 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29111 PyObject *resultobj = 0;
29112 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29113 wxTimeSpan result;
29114 void *argp1 = 0 ;
29115 int res1 = 0 ;
29116 PyObject *swig_obj[1] ;
29117
29118 if (!args) SWIG_fail;
29119 swig_obj[0] = args;
29120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29121 if (!SWIG_IsOK(res1)) {
29122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29123 }
29124 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29125 {
29126 PyThreadState* __tstate = wxPyBeginAllowThreads();
29127 result = ((wxTimeSpan const *)arg1)->Abs();
29128 wxPyEndAllowThreads(__tstate);
29129 if (PyErr_Occurred()) SWIG_fail;
29130 }
29131 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29132 return resultobj;
29133 fail:
29134 return NULL;
29135 }
29136
29137
29138 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29139 PyObject *resultobj = 0;
29140 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29141 wxTimeSpan *arg2 = 0 ;
29142 wxTimeSpan *result = 0 ;
29143 void *argp1 = 0 ;
29144 int res1 = 0 ;
29145 void *argp2 = 0 ;
29146 int res2 = 0 ;
29147 PyObject * obj0 = 0 ;
29148 PyObject * obj1 = 0 ;
29149 char * kwnames[] = {
29150 (char *) "self",(char *) "diff", NULL
29151 };
29152
29153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29155 if (!SWIG_IsOK(res1)) {
29156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29157 }
29158 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29160 if (!SWIG_IsOK(res2)) {
29161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29162 }
29163 if (!argp2) {
29164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29165 }
29166 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29167 {
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 {
29170 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29171 result = (wxTimeSpan *) &_result_ref;
29172 }
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29184 PyObject *resultobj = 0;
29185 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29186 wxTimeSpan *arg2 = 0 ;
29187 wxTimeSpan *result = 0 ;
29188 void *argp1 = 0 ;
29189 int res1 = 0 ;
29190 void *argp2 = 0 ;
29191 int res2 = 0 ;
29192 PyObject * obj0 = 0 ;
29193 PyObject * obj1 = 0 ;
29194 char * kwnames[] = {
29195 (char *) "self",(char *) "diff", NULL
29196 };
29197
29198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29200 if (!SWIG_IsOK(res1)) {
29201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29202 }
29203 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29205 if (!SWIG_IsOK(res2)) {
29206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29207 }
29208 if (!argp2) {
29209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29210 }
29211 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29212 {
29213 PyThreadState* __tstate = wxPyBeginAllowThreads();
29214 {
29215 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29216 result = (wxTimeSpan *) &_result_ref;
29217 }
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29222 return resultobj;
29223 fail:
29224 return NULL;
29225 }
29226
29227
29228 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29229 PyObject *resultobj = 0;
29230 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29231 int arg2 ;
29232 wxTimeSpan *result = 0 ;
29233 void *argp1 = 0 ;
29234 int res1 = 0 ;
29235 int val2 ;
29236 int ecode2 = 0 ;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 char * kwnames[] = {
29240 (char *) "self",(char *) "n", NULL
29241 };
29242
29243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29245 if (!SWIG_IsOK(res1)) {
29246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29247 }
29248 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29249 ecode2 = SWIG_AsVal_int(obj1, &val2);
29250 if (!SWIG_IsOK(ecode2)) {
29251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29252 }
29253 arg2 = static_cast< int >(val2);
29254 {
29255 PyThreadState* __tstate = wxPyBeginAllowThreads();
29256 {
29257 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29258 result = (wxTimeSpan *) &_result_ref;
29259 }
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29271 PyObject *resultobj = 0;
29272 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29273 wxTimeSpan *result = 0 ;
29274 void *argp1 = 0 ;
29275 int res1 = 0 ;
29276 PyObject *swig_obj[1] ;
29277
29278 if (!args) SWIG_fail;
29279 swig_obj[0] = args;
29280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29281 if (!SWIG_IsOK(res1)) {
29282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29283 }
29284 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 {
29288 wxTimeSpan &_result_ref = (arg1)->operator -();
29289 result = (wxTimeSpan *) &_result_ref;
29290 }
29291 wxPyEndAllowThreads(__tstate);
29292 if (PyErr_Occurred()) SWIG_fail;
29293 }
29294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29295 return resultobj;
29296 fail:
29297 return NULL;
29298 }
29299
29300
29301 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29302 PyObject *resultobj = 0;
29303 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29304 wxTimeSpan *arg2 = 0 ;
29305 wxTimeSpan result;
29306 void *argp1 = 0 ;
29307 int res1 = 0 ;
29308 void *argp2 = 0 ;
29309 int res2 = 0 ;
29310 PyObject * obj0 = 0 ;
29311 PyObject * obj1 = 0 ;
29312 char * kwnames[] = {
29313 (char *) "self",(char *) "other", NULL
29314 };
29315
29316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29318 if (!SWIG_IsOK(res1)) {
29319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29320 }
29321 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29322 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29323 if (!SWIG_IsOK(res2)) {
29324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29325 }
29326 if (!argp2) {
29327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29328 }
29329 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29330 {
29331 PyThreadState* __tstate = wxPyBeginAllowThreads();
29332 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29333 wxPyEndAllowThreads(__tstate);
29334 if (PyErr_Occurred()) SWIG_fail;
29335 }
29336 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj = 0;
29345 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29346 wxTimeSpan *arg2 = 0 ;
29347 wxTimeSpan result;
29348 void *argp1 = 0 ;
29349 int res1 = 0 ;
29350 void *argp2 = 0 ;
29351 int res2 = 0 ;
29352 PyObject * obj0 = 0 ;
29353 PyObject * obj1 = 0 ;
29354 char * kwnames[] = {
29355 (char *) "self",(char *) "other", NULL
29356 };
29357
29358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29360 if (!SWIG_IsOK(res1)) {
29361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29362 }
29363 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29365 if (!SWIG_IsOK(res2)) {
29366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29367 }
29368 if (!argp2) {
29369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29370 }
29371 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29372 {
29373 PyThreadState* __tstate = wxPyBeginAllowThreads();
29374 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29375 wxPyEndAllowThreads(__tstate);
29376 if (PyErr_Occurred()) SWIG_fail;
29377 }
29378 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29379 return resultobj;
29380 fail:
29381 return NULL;
29382 }
29383
29384
29385 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29386 PyObject *resultobj = 0;
29387 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29388 int arg2 ;
29389 wxTimeSpan result;
29390 void *argp1 = 0 ;
29391 int res1 = 0 ;
29392 int val2 ;
29393 int ecode2 = 0 ;
29394 PyObject * obj0 = 0 ;
29395 PyObject * obj1 = 0 ;
29396 char * kwnames[] = {
29397 (char *) "self",(char *) "n", NULL
29398 };
29399
29400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29402 if (!SWIG_IsOK(res1)) {
29403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29404 }
29405 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29406 ecode2 = SWIG_AsVal_int(obj1, &val2);
29407 if (!SWIG_IsOK(ecode2)) {
29408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29409 }
29410 arg2 = static_cast< int >(val2);
29411 {
29412 PyThreadState* __tstate = wxPyBeginAllowThreads();
29413 result = wxTimeSpan___mul__(arg1,arg2);
29414 wxPyEndAllowThreads(__tstate);
29415 if (PyErr_Occurred()) SWIG_fail;
29416 }
29417 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29418 return resultobj;
29419 fail:
29420 return NULL;
29421 }
29422
29423
29424 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29425 PyObject *resultobj = 0;
29426 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29427 int arg2 ;
29428 wxTimeSpan result;
29429 void *argp1 = 0 ;
29430 int res1 = 0 ;
29431 int val2 ;
29432 int ecode2 = 0 ;
29433 PyObject * obj0 = 0 ;
29434 PyObject * obj1 = 0 ;
29435 char * kwnames[] = {
29436 (char *) "self",(char *) "n", NULL
29437 };
29438
29439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29441 if (!SWIG_IsOK(res1)) {
29442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29443 }
29444 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29445 ecode2 = SWIG_AsVal_int(obj1, &val2);
29446 if (!SWIG_IsOK(ecode2)) {
29447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29448 }
29449 arg2 = static_cast< int >(val2);
29450 {
29451 PyThreadState* __tstate = wxPyBeginAllowThreads();
29452 result = wxTimeSpan___rmul__(arg1,arg2);
29453 wxPyEndAllowThreads(__tstate);
29454 if (PyErr_Occurred()) SWIG_fail;
29455 }
29456 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29457 return resultobj;
29458 fail:
29459 return NULL;
29460 }
29461
29462
29463 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29464 PyObject *resultobj = 0;
29465 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29466 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29467 bool result;
29468 void *argp1 = 0 ;
29469 int res1 = 0 ;
29470 void *argp2 = 0 ;
29471 int res2 = 0 ;
29472 PyObject * obj0 = 0 ;
29473 PyObject * obj1 = 0 ;
29474 char * kwnames[] = {
29475 (char *) "self",(char *) "other", NULL
29476 };
29477
29478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29480 if (!SWIG_IsOK(res1)) {
29481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29482 }
29483 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29485 if (!SWIG_IsOK(res2)) {
29486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29487 }
29488 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29489 {
29490 PyThreadState* __tstate = wxPyBeginAllowThreads();
29491 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29492 wxPyEndAllowThreads(__tstate);
29493 if (PyErr_Occurred()) SWIG_fail;
29494 }
29495 {
29496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29497 }
29498 return resultobj;
29499 fail:
29500 return NULL;
29501 }
29502
29503
29504 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29505 PyObject *resultobj = 0;
29506 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29507 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29508 bool result;
29509 void *argp1 = 0 ;
29510 int res1 = 0 ;
29511 void *argp2 = 0 ;
29512 int res2 = 0 ;
29513 PyObject * obj0 = 0 ;
29514 PyObject * obj1 = 0 ;
29515 char * kwnames[] = {
29516 (char *) "self",(char *) "other", NULL
29517 };
29518
29519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29521 if (!SWIG_IsOK(res1)) {
29522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29523 }
29524 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29525 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29526 if (!SWIG_IsOK(res2)) {
29527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29528 }
29529 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29530 {
29531 PyThreadState* __tstate = wxPyBeginAllowThreads();
29532 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29533 wxPyEndAllowThreads(__tstate);
29534 if (PyErr_Occurred()) SWIG_fail;
29535 }
29536 {
29537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29538 }
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj = 0;
29547 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29548 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29549 bool result;
29550 void *argp1 = 0 ;
29551 int res1 = 0 ;
29552 void *argp2 = 0 ;
29553 int res2 = 0 ;
29554 PyObject * obj0 = 0 ;
29555 PyObject * obj1 = 0 ;
29556 char * kwnames[] = {
29557 (char *) "self",(char *) "other", NULL
29558 };
29559
29560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29562 if (!SWIG_IsOK(res1)) {
29563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29564 }
29565 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29567 if (!SWIG_IsOK(res2)) {
29568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29569 }
29570 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29574 wxPyEndAllowThreads(__tstate);
29575 if (PyErr_Occurred()) SWIG_fail;
29576 }
29577 {
29578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29579 }
29580 return resultobj;
29581 fail:
29582 return NULL;
29583 }
29584
29585
29586 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29587 PyObject *resultobj = 0;
29588 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29589 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29590 bool result;
29591 void *argp1 = 0 ;
29592 int res1 = 0 ;
29593 void *argp2 = 0 ;
29594 int res2 = 0 ;
29595 PyObject * obj0 = 0 ;
29596 PyObject * obj1 = 0 ;
29597 char * kwnames[] = {
29598 (char *) "self",(char *) "other", NULL
29599 };
29600
29601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29603 if (!SWIG_IsOK(res1)) {
29604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29605 }
29606 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29608 if (!SWIG_IsOK(res2)) {
29609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29610 }
29611 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29612 {
29613 PyThreadState* __tstate = wxPyBeginAllowThreads();
29614 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29615 wxPyEndAllowThreads(__tstate);
29616 if (PyErr_Occurred()) SWIG_fail;
29617 }
29618 {
29619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29620 }
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29628 PyObject *resultobj = 0;
29629 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29630 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29631 bool result;
29632 void *argp1 = 0 ;
29633 int res1 = 0 ;
29634 void *argp2 = 0 ;
29635 int res2 = 0 ;
29636 PyObject * obj0 = 0 ;
29637 PyObject * obj1 = 0 ;
29638 char * kwnames[] = {
29639 (char *) "self",(char *) "other", NULL
29640 };
29641
29642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29644 if (!SWIG_IsOK(res1)) {
29645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29646 }
29647 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29648 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29649 if (!SWIG_IsOK(res2)) {
29650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29651 }
29652 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29653 {
29654 PyThreadState* __tstate = wxPyBeginAllowThreads();
29655 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29656 wxPyEndAllowThreads(__tstate);
29657 if (PyErr_Occurred()) SWIG_fail;
29658 }
29659 {
29660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29661 }
29662 return resultobj;
29663 fail:
29664 return NULL;
29665 }
29666
29667
29668 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29669 PyObject *resultobj = 0;
29670 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29671 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29672 bool result;
29673 void *argp1 = 0 ;
29674 int res1 = 0 ;
29675 void *argp2 = 0 ;
29676 int res2 = 0 ;
29677 PyObject * obj0 = 0 ;
29678 PyObject * obj1 = 0 ;
29679 char * kwnames[] = {
29680 (char *) "self",(char *) "other", NULL
29681 };
29682
29683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29685 if (!SWIG_IsOK(res1)) {
29686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29687 }
29688 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29690 if (!SWIG_IsOK(res2)) {
29691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29692 }
29693 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29702 }
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29710 PyObject *resultobj = 0;
29711 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29712 bool result;
29713 void *argp1 = 0 ;
29714 int res1 = 0 ;
29715 PyObject *swig_obj[1] ;
29716
29717 if (!args) SWIG_fail;
29718 swig_obj[0] = args;
29719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29720 if (!SWIG_IsOK(res1)) {
29721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29722 }
29723 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29724 {
29725 PyThreadState* __tstate = wxPyBeginAllowThreads();
29726 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29727 wxPyEndAllowThreads(__tstate);
29728 if (PyErr_Occurred()) SWIG_fail;
29729 }
29730 {
29731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29732 }
29733 return resultobj;
29734 fail:
29735 return NULL;
29736 }
29737
29738
29739 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29740 PyObject *resultobj = 0;
29741 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29742 bool result;
29743 void *argp1 = 0 ;
29744 int res1 = 0 ;
29745 PyObject *swig_obj[1] ;
29746
29747 if (!args) SWIG_fail;
29748 swig_obj[0] = args;
29749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29750 if (!SWIG_IsOK(res1)) {
29751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29752 }
29753 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29754 {
29755 PyThreadState* __tstate = wxPyBeginAllowThreads();
29756 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29757 wxPyEndAllowThreads(__tstate);
29758 if (PyErr_Occurred()) SWIG_fail;
29759 }
29760 {
29761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29762 }
29763 return resultobj;
29764 fail:
29765 return NULL;
29766 }
29767
29768
29769 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29770 PyObject *resultobj = 0;
29771 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29772 bool result;
29773 void *argp1 = 0 ;
29774 int res1 = 0 ;
29775 PyObject *swig_obj[1] ;
29776
29777 if (!args) SWIG_fail;
29778 swig_obj[0] = args;
29779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29780 if (!SWIG_IsOK(res1)) {
29781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29782 }
29783 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29784 {
29785 PyThreadState* __tstate = wxPyBeginAllowThreads();
29786 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29787 wxPyEndAllowThreads(__tstate);
29788 if (PyErr_Occurred()) SWIG_fail;
29789 }
29790 {
29791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29792 }
29793 return resultobj;
29794 fail:
29795 return NULL;
29796 }
29797
29798
29799 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29800 PyObject *resultobj = 0;
29801 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29802 wxTimeSpan *arg2 = 0 ;
29803 bool result;
29804 void *argp1 = 0 ;
29805 int res1 = 0 ;
29806 void *argp2 = 0 ;
29807 int res2 = 0 ;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 char * kwnames[] = {
29811 (char *) "self",(char *) "ts", NULL
29812 };
29813
29814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29816 if (!SWIG_IsOK(res1)) {
29817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29818 }
29819 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29821 if (!SWIG_IsOK(res2)) {
29822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29823 }
29824 if (!argp2) {
29825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29826 }
29827 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29828 {
29829 PyThreadState* __tstate = wxPyBeginAllowThreads();
29830 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29831 wxPyEndAllowThreads(__tstate);
29832 if (PyErr_Occurred()) SWIG_fail;
29833 }
29834 {
29835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29836 }
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29844 PyObject *resultobj = 0;
29845 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29846 wxTimeSpan *arg2 = 0 ;
29847 bool result;
29848 void *argp1 = 0 ;
29849 int res1 = 0 ;
29850 void *argp2 = 0 ;
29851 int res2 = 0 ;
29852 PyObject * obj0 = 0 ;
29853 PyObject * obj1 = 0 ;
29854 char * kwnames[] = {
29855 (char *) "self",(char *) "ts", NULL
29856 };
29857
29858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29860 if (!SWIG_IsOK(res1)) {
29861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29862 }
29863 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29865 if (!SWIG_IsOK(res2)) {
29866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29867 }
29868 if (!argp2) {
29869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29870 }
29871 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29872 {
29873 PyThreadState* __tstate = wxPyBeginAllowThreads();
29874 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29875 wxPyEndAllowThreads(__tstate);
29876 if (PyErr_Occurred()) SWIG_fail;
29877 }
29878 {
29879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29880 }
29881 return resultobj;
29882 fail:
29883 return NULL;
29884 }
29885
29886
29887 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29888 PyObject *resultobj = 0;
29889 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29890 wxTimeSpan *arg2 = 0 ;
29891 bool result;
29892 void *argp1 = 0 ;
29893 int res1 = 0 ;
29894 void *argp2 = 0 ;
29895 int res2 = 0 ;
29896 PyObject * obj0 = 0 ;
29897 PyObject * obj1 = 0 ;
29898 char * kwnames[] = {
29899 (char *) "self",(char *) "t", NULL
29900 };
29901
29902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29904 if (!SWIG_IsOK(res1)) {
29905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29906 }
29907 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29908 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29909 if (!SWIG_IsOK(res2)) {
29910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29911 }
29912 if (!argp2) {
29913 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29914 }
29915 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29916 {
29917 PyThreadState* __tstate = wxPyBeginAllowThreads();
29918 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29919 wxPyEndAllowThreads(__tstate);
29920 if (PyErr_Occurred()) SWIG_fail;
29921 }
29922 {
29923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29924 }
29925 return resultobj;
29926 fail:
29927 return NULL;
29928 }
29929
29930
29931 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29932 PyObject *resultobj = 0;
29933 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29934 int result;
29935 void *argp1 = 0 ;
29936 int res1 = 0 ;
29937 PyObject *swig_obj[1] ;
29938
29939 if (!args) SWIG_fail;
29940 swig_obj[0] = args;
29941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29942 if (!SWIG_IsOK(res1)) {
29943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29944 }
29945 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29946 {
29947 PyThreadState* __tstate = wxPyBeginAllowThreads();
29948 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29949 wxPyEndAllowThreads(__tstate);
29950 if (PyErr_Occurred()) SWIG_fail;
29951 }
29952 resultobj = SWIG_From_int(static_cast< int >(result));
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29960 PyObject *resultobj = 0;
29961 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29962 int result;
29963 void *argp1 = 0 ;
29964 int res1 = 0 ;
29965 PyObject *swig_obj[1] ;
29966
29967 if (!args) SWIG_fail;
29968 swig_obj[0] = args;
29969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29970 if (!SWIG_IsOK(res1)) {
29971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29972 }
29973 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29974 {
29975 PyThreadState* __tstate = wxPyBeginAllowThreads();
29976 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 resultobj = SWIG_From_int(static_cast< int >(result));
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29988 PyObject *resultobj = 0;
29989 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29990 int result;
29991 void *argp1 = 0 ;
29992 int res1 = 0 ;
29993 PyObject *swig_obj[1] ;
29994
29995 if (!args) SWIG_fail;
29996 swig_obj[0] = args;
29997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29998 if (!SWIG_IsOK(res1)) {
29999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30000 }
30001 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30005 wxPyEndAllowThreads(__tstate);
30006 if (PyErr_Occurred()) SWIG_fail;
30007 }
30008 resultobj = SWIG_From_int(static_cast< int >(result));
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30016 PyObject *resultobj = 0;
30017 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30018 int result;
30019 void *argp1 = 0 ;
30020 int res1 = 0 ;
30021 PyObject *swig_obj[1] ;
30022
30023 if (!args) SWIG_fail;
30024 swig_obj[0] = args;
30025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30026 if (!SWIG_IsOK(res1)) {
30027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30028 }
30029 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 resultobj = SWIG_From_int(static_cast< int >(result));
30037 return resultobj;
30038 fail:
30039 return NULL;
30040 }
30041
30042
30043 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30044 PyObject *resultobj = 0;
30045 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30046 wxLongLong result;
30047 void *argp1 = 0 ;
30048 int res1 = 0 ;
30049 PyObject *swig_obj[1] ;
30050
30051 if (!args) SWIG_fail;
30052 swig_obj[0] = args;
30053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30056 }
30057 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30058 {
30059 PyThreadState* __tstate = wxPyBeginAllowThreads();
30060 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 {
30065 PyObject *hi, *lo, *shifter, *shifted;
30066 hi = PyLong_FromLong( (&result)->GetHi() );
30067 lo = PyLong_FromLong( (&result)->GetLo() );
30068 shifter = PyLong_FromLong(32);
30069 shifted = PyNumber_Lshift(hi, shifter);
30070 resultobj = PyNumber_Or(shifted, lo);
30071 Py_DECREF(hi);
30072 Py_DECREF(lo);
30073 Py_DECREF(shifter);
30074 Py_DECREF(shifted);
30075 }
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30083 PyObject *resultobj = 0;
30084 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30085 wxLongLong result;
30086 void *argp1 = 0 ;
30087 int res1 = 0 ;
30088 PyObject *swig_obj[1] ;
30089
30090 if (!args) SWIG_fail;
30091 swig_obj[0] = args;
30092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30093 if (!SWIG_IsOK(res1)) {
30094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30095 }
30096 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30097 {
30098 PyThreadState* __tstate = wxPyBeginAllowThreads();
30099 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30100 wxPyEndAllowThreads(__tstate);
30101 if (PyErr_Occurred()) SWIG_fail;
30102 }
30103 {
30104 PyObject *hi, *lo, *shifter, *shifted;
30105 hi = PyLong_FromLong( (&result)->GetHi() );
30106 lo = PyLong_FromLong( (&result)->GetLo() );
30107 shifter = PyLong_FromLong(32);
30108 shifted = PyNumber_Lshift(hi, shifter);
30109 resultobj = PyNumber_Or(shifted, lo);
30110 Py_DECREF(hi);
30111 Py_DECREF(lo);
30112 Py_DECREF(shifter);
30113 Py_DECREF(shifted);
30114 }
30115 return resultobj;
30116 fail:
30117 return NULL;
30118 }
30119
30120
30121 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30122 PyObject *resultobj = 0;
30123 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30124 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30125 wxString *arg2 = (wxString *) &arg2_defvalue ;
30126 wxString result;
30127 void *argp1 = 0 ;
30128 int res1 = 0 ;
30129 bool temp2 = false ;
30130 PyObject * obj0 = 0 ;
30131 PyObject * obj1 = 0 ;
30132 char * kwnames[] = {
30133 (char *) "self",(char *) "format", NULL
30134 };
30135
30136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30138 if (!SWIG_IsOK(res1)) {
30139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30140 }
30141 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30142 if (obj1) {
30143 {
30144 arg2 = wxString_in_helper(obj1);
30145 if (arg2 == NULL) SWIG_fail;
30146 temp2 = true;
30147 }
30148 }
30149 {
30150 PyThreadState* __tstate = wxPyBeginAllowThreads();
30151 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30152 wxPyEndAllowThreads(__tstate);
30153 if (PyErr_Occurred()) SWIG_fail;
30154 }
30155 {
30156 #if wxUSE_UNICODE
30157 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30158 #else
30159 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30160 #endif
30161 }
30162 {
30163 if (temp2)
30164 delete arg2;
30165 }
30166 return resultobj;
30167 fail:
30168 {
30169 if (temp2)
30170 delete arg2;
30171 }
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30177 PyObject *obj;
30178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30179 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30180 return SWIG_Py_Void();
30181 }
30182
30183 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30184 return SWIG_Python_InitShadowInstance(args);
30185 }
30186
30187 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30188 PyObject *resultobj = 0;
30189 int arg1 = (int) 0 ;
30190 int arg2 = (int) 0 ;
30191 int arg3 = (int) 0 ;
30192 int arg4 = (int) 0 ;
30193 wxDateSpan *result = 0 ;
30194 int val1 ;
30195 int ecode1 = 0 ;
30196 int val2 ;
30197 int ecode2 = 0 ;
30198 int val3 ;
30199 int ecode3 = 0 ;
30200 int val4 ;
30201 int ecode4 = 0 ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 PyObject * obj2 = 0 ;
30205 PyObject * obj3 = 0 ;
30206 char * kwnames[] = {
30207 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30208 };
30209
30210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30211 if (obj0) {
30212 ecode1 = SWIG_AsVal_int(obj0, &val1);
30213 if (!SWIG_IsOK(ecode1)) {
30214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30215 }
30216 arg1 = static_cast< int >(val1);
30217 }
30218 if (obj1) {
30219 ecode2 = SWIG_AsVal_int(obj1, &val2);
30220 if (!SWIG_IsOK(ecode2)) {
30221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30222 }
30223 arg2 = static_cast< int >(val2);
30224 }
30225 if (obj2) {
30226 ecode3 = SWIG_AsVal_int(obj2, &val3);
30227 if (!SWIG_IsOK(ecode3)) {
30228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30229 }
30230 arg3 = static_cast< int >(val3);
30231 }
30232 if (obj3) {
30233 ecode4 = SWIG_AsVal_int(obj3, &val4);
30234 if (!SWIG_IsOK(ecode4)) {
30235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30236 }
30237 arg4 = static_cast< int >(val4);
30238 }
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30246 return resultobj;
30247 fail:
30248 return NULL;
30249 }
30250
30251
30252 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30253 PyObject *resultobj = 0;
30254 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30255 void *argp1 = 0 ;
30256 int res1 = 0 ;
30257 PyObject *swig_obj[1] ;
30258
30259 if (!args) SWIG_fail;
30260 swig_obj[0] = args;
30261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30262 if (!SWIG_IsOK(res1)) {
30263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30264 }
30265 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 delete arg1;
30269
30270 wxPyEndAllowThreads(__tstate);
30271 if (PyErr_Occurred()) SWIG_fail;
30272 }
30273 resultobj = SWIG_Py_Void();
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30281 PyObject *resultobj = 0;
30282 int arg1 ;
30283 wxDateSpan result;
30284 int val1 ;
30285 int ecode1 = 0 ;
30286 PyObject * obj0 = 0 ;
30287 char * kwnames[] = {
30288 (char *) "days", NULL
30289 };
30290
30291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30292 ecode1 = SWIG_AsVal_int(obj0, &val1);
30293 if (!SWIG_IsOK(ecode1)) {
30294 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30295 }
30296 arg1 = static_cast< int >(val1);
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 result = wxDateSpan::Days(arg1);
30300 wxPyEndAllowThreads(__tstate);
30301 if (PyErr_Occurred()) SWIG_fail;
30302 }
30303 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30304 return resultobj;
30305 fail:
30306 return NULL;
30307 }
30308
30309
30310 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30311 PyObject *resultobj = 0;
30312 wxDateSpan result;
30313
30314 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30315 {
30316 PyThreadState* __tstate = wxPyBeginAllowThreads();
30317 result = wxDateSpan::Day();
30318 wxPyEndAllowThreads(__tstate);
30319 if (PyErr_Occurred()) SWIG_fail;
30320 }
30321 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30329 PyObject *resultobj = 0;
30330 int arg1 ;
30331 wxDateSpan result;
30332 int val1 ;
30333 int ecode1 = 0 ;
30334 PyObject * obj0 = 0 ;
30335 char * kwnames[] = {
30336 (char *) "weeks", NULL
30337 };
30338
30339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30340 ecode1 = SWIG_AsVal_int(obj0, &val1);
30341 if (!SWIG_IsOK(ecode1)) {
30342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30343 }
30344 arg1 = static_cast< int >(val1);
30345 {
30346 PyThreadState* __tstate = wxPyBeginAllowThreads();
30347 result = wxDateSpan::Weeks(arg1);
30348 wxPyEndAllowThreads(__tstate);
30349 if (PyErr_Occurred()) SWIG_fail;
30350 }
30351 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30352 return resultobj;
30353 fail:
30354 return NULL;
30355 }
30356
30357
30358 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30359 PyObject *resultobj = 0;
30360 wxDateSpan result;
30361
30362 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = wxDateSpan::Week();
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30377 PyObject *resultobj = 0;
30378 int arg1 ;
30379 wxDateSpan result;
30380 int val1 ;
30381 int ecode1 = 0 ;
30382 PyObject * obj0 = 0 ;
30383 char * kwnames[] = {
30384 (char *) "mon", NULL
30385 };
30386
30387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30388 ecode1 = SWIG_AsVal_int(obj0, &val1);
30389 if (!SWIG_IsOK(ecode1)) {
30390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30391 }
30392 arg1 = static_cast< int >(val1);
30393 {
30394 PyThreadState* __tstate = wxPyBeginAllowThreads();
30395 result = wxDateSpan::Months(arg1);
30396 wxPyEndAllowThreads(__tstate);
30397 if (PyErr_Occurred()) SWIG_fail;
30398 }
30399 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30400 return resultobj;
30401 fail:
30402 return NULL;
30403 }
30404
30405
30406 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30407 PyObject *resultobj = 0;
30408 wxDateSpan result;
30409
30410 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 result = wxDateSpan::Month();
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj = 0;
30426 int arg1 ;
30427 wxDateSpan result;
30428 int val1 ;
30429 int ecode1 = 0 ;
30430 PyObject * obj0 = 0 ;
30431 char * kwnames[] = {
30432 (char *) "years", NULL
30433 };
30434
30435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30436 ecode1 = SWIG_AsVal_int(obj0, &val1);
30437 if (!SWIG_IsOK(ecode1)) {
30438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30439 }
30440 arg1 = static_cast< int >(val1);
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 result = wxDateSpan::Years(arg1);
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30455 PyObject *resultobj = 0;
30456 wxDateSpan result;
30457
30458 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 result = wxDateSpan::Year();
30462 wxPyEndAllowThreads(__tstate);
30463 if (PyErr_Occurred()) SWIG_fail;
30464 }
30465 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30473 PyObject *resultobj = 0;
30474 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30475 int arg2 ;
30476 wxDateSpan *result = 0 ;
30477 void *argp1 = 0 ;
30478 int res1 = 0 ;
30479 int val2 ;
30480 int ecode2 = 0 ;
30481 PyObject * obj0 = 0 ;
30482 PyObject * obj1 = 0 ;
30483 char * kwnames[] = {
30484 (char *) "self",(char *) "n", NULL
30485 };
30486
30487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30489 if (!SWIG_IsOK(res1)) {
30490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30491 }
30492 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30493 ecode2 = SWIG_AsVal_int(obj1, &val2);
30494 if (!SWIG_IsOK(ecode2)) {
30495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30496 }
30497 arg2 = static_cast< int >(val2);
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 {
30501 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30502 result = (wxDateSpan *) &_result_ref;
30503 }
30504 wxPyEndAllowThreads(__tstate);
30505 if (PyErr_Occurred()) SWIG_fail;
30506 }
30507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj = 0;
30516 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30517 int arg2 ;
30518 wxDateSpan *result = 0 ;
30519 void *argp1 = 0 ;
30520 int res1 = 0 ;
30521 int val2 ;
30522 int ecode2 = 0 ;
30523 PyObject * obj0 = 0 ;
30524 PyObject * obj1 = 0 ;
30525 char * kwnames[] = {
30526 (char *) "self",(char *) "n", NULL
30527 };
30528
30529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30531 if (!SWIG_IsOK(res1)) {
30532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30533 }
30534 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30535 ecode2 = SWIG_AsVal_int(obj1, &val2);
30536 if (!SWIG_IsOK(ecode2)) {
30537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30538 }
30539 arg2 = static_cast< int >(val2);
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 {
30543 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30544 result = (wxDateSpan *) &_result_ref;
30545 }
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30557 PyObject *resultobj = 0;
30558 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30559 int arg2 ;
30560 wxDateSpan *result = 0 ;
30561 void *argp1 = 0 ;
30562 int res1 = 0 ;
30563 int val2 ;
30564 int ecode2 = 0 ;
30565 PyObject * obj0 = 0 ;
30566 PyObject * obj1 = 0 ;
30567 char * kwnames[] = {
30568 (char *) "self",(char *) "n", NULL
30569 };
30570
30571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30573 if (!SWIG_IsOK(res1)) {
30574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30575 }
30576 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30577 ecode2 = SWIG_AsVal_int(obj1, &val2);
30578 if (!SWIG_IsOK(ecode2)) {
30579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30580 }
30581 arg2 = static_cast< int >(val2);
30582 {
30583 PyThreadState* __tstate = wxPyBeginAllowThreads();
30584 {
30585 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30586 result = (wxDateSpan *) &_result_ref;
30587 }
30588 wxPyEndAllowThreads(__tstate);
30589 if (PyErr_Occurred()) SWIG_fail;
30590 }
30591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30599 PyObject *resultobj = 0;
30600 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30601 int arg2 ;
30602 wxDateSpan *result = 0 ;
30603 void *argp1 = 0 ;
30604 int res1 = 0 ;
30605 int val2 ;
30606 int ecode2 = 0 ;
30607 PyObject * obj0 = 0 ;
30608 PyObject * obj1 = 0 ;
30609 char * kwnames[] = {
30610 (char *) "self",(char *) "n", NULL
30611 };
30612
30613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30615 if (!SWIG_IsOK(res1)) {
30616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30617 }
30618 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30619 ecode2 = SWIG_AsVal_int(obj1, &val2);
30620 if (!SWIG_IsOK(ecode2)) {
30621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30622 }
30623 arg2 = static_cast< int >(val2);
30624 {
30625 PyThreadState* __tstate = wxPyBeginAllowThreads();
30626 {
30627 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30628 result = (wxDateSpan *) &_result_ref;
30629 }
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30641 PyObject *resultobj = 0;
30642 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30643 int result;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 PyObject *swig_obj[1] ;
30647
30648 if (!args) SWIG_fail;
30649 swig_obj[0] = args;
30650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30651 if (!SWIG_IsOK(res1)) {
30652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30653 }
30654 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30655 {
30656 PyThreadState* __tstate = wxPyBeginAllowThreads();
30657 result = (int)((wxDateSpan const *)arg1)->GetYears();
30658 wxPyEndAllowThreads(__tstate);
30659 if (PyErr_Occurred()) SWIG_fail;
30660 }
30661 resultobj = SWIG_From_int(static_cast< int >(result));
30662 return resultobj;
30663 fail:
30664 return NULL;
30665 }
30666
30667
30668 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30669 PyObject *resultobj = 0;
30670 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30671 int result;
30672 void *argp1 = 0 ;
30673 int res1 = 0 ;
30674 PyObject *swig_obj[1] ;
30675
30676 if (!args) SWIG_fail;
30677 swig_obj[0] = args;
30678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30679 if (!SWIG_IsOK(res1)) {
30680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30681 }
30682 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30683 {
30684 PyThreadState* __tstate = wxPyBeginAllowThreads();
30685 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30686 wxPyEndAllowThreads(__tstate);
30687 if (PyErr_Occurred()) SWIG_fail;
30688 }
30689 resultobj = SWIG_From_int(static_cast< int >(result));
30690 return resultobj;
30691 fail:
30692 return NULL;
30693 }
30694
30695
30696 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30697 PyObject *resultobj = 0;
30698 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30699 int result;
30700 void *argp1 = 0 ;
30701 int res1 = 0 ;
30702 PyObject *swig_obj[1] ;
30703
30704 if (!args) SWIG_fail;
30705 swig_obj[0] = args;
30706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30707 if (!SWIG_IsOK(res1)) {
30708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30709 }
30710 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_From_int(static_cast< int >(result));
30718 return resultobj;
30719 fail:
30720 return NULL;
30721 }
30722
30723
30724 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30725 PyObject *resultobj = 0;
30726 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30727 int result;
30728 void *argp1 = 0 ;
30729 int res1 = 0 ;
30730 PyObject *swig_obj[1] ;
30731
30732 if (!args) SWIG_fail;
30733 swig_obj[0] = args;
30734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30735 if (!SWIG_IsOK(res1)) {
30736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30737 }
30738 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30739 {
30740 PyThreadState* __tstate = wxPyBeginAllowThreads();
30741 result = (int)((wxDateSpan const *)arg1)->GetDays();
30742 wxPyEndAllowThreads(__tstate);
30743 if (PyErr_Occurred()) SWIG_fail;
30744 }
30745 resultobj = SWIG_From_int(static_cast< int >(result));
30746 return resultobj;
30747 fail:
30748 return NULL;
30749 }
30750
30751
30752 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30753 PyObject *resultobj = 0;
30754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30755 int result;
30756 void *argp1 = 0 ;
30757 int res1 = 0 ;
30758 PyObject *swig_obj[1] ;
30759
30760 if (!args) SWIG_fail;
30761 swig_obj[0] = args;
30762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30763 if (!SWIG_IsOK(res1)) {
30764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30765 }
30766 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_From_int(static_cast< int >(result));
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj = 0;
30782 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30783 wxDateSpan *arg2 = 0 ;
30784 wxDateSpan *result = 0 ;
30785 void *argp1 = 0 ;
30786 int res1 = 0 ;
30787 void *argp2 = 0 ;
30788 int res2 = 0 ;
30789 PyObject * obj0 = 0 ;
30790 PyObject * obj1 = 0 ;
30791 char * kwnames[] = {
30792 (char *) "self",(char *) "other", NULL
30793 };
30794
30795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30797 if (!SWIG_IsOK(res1)) {
30798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30799 }
30800 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30802 if (!SWIG_IsOK(res2)) {
30803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30804 }
30805 if (!argp2) {
30806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30807 }
30808 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30809 {
30810 PyThreadState* __tstate = wxPyBeginAllowThreads();
30811 {
30812 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30813 result = (wxDateSpan *) &_result_ref;
30814 }
30815 wxPyEndAllowThreads(__tstate);
30816 if (PyErr_Occurred()) SWIG_fail;
30817 }
30818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30819 return resultobj;
30820 fail:
30821 return NULL;
30822 }
30823
30824
30825 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30826 PyObject *resultobj = 0;
30827 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30828 wxDateSpan *arg2 = 0 ;
30829 wxDateSpan *result = 0 ;
30830 void *argp1 = 0 ;
30831 int res1 = 0 ;
30832 void *argp2 = 0 ;
30833 int res2 = 0 ;
30834 PyObject * obj0 = 0 ;
30835 PyObject * obj1 = 0 ;
30836 char * kwnames[] = {
30837 (char *) "self",(char *) "other", NULL
30838 };
30839
30840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30842 if (!SWIG_IsOK(res1)) {
30843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30844 }
30845 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30846 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30847 if (!SWIG_IsOK(res2)) {
30848 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30849 }
30850 if (!argp2) {
30851 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30852 }
30853 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 {
30857 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30858 result = (wxDateSpan *) &_result_ref;
30859 }
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30864 return resultobj;
30865 fail:
30866 return NULL;
30867 }
30868
30869
30870 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30871 PyObject *resultobj = 0;
30872 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30873 wxDateSpan *result = 0 ;
30874 void *argp1 = 0 ;
30875 int res1 = 0 ;
30876 PyObject *swig_obj[1] ;
30877
30878 if (!args) SWIG_fail;
30879 swig_obj[0] = args;
30880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30883 }
30884 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 {
30888 wxDateSpan &_result_ref = (arg1)->Neg();
30889 result = (wxDateSpan *) &_result_ref;
30890 }
30891 wxPyEndAllowThreads(__tstate);
30892 if (PyErr_Occurred()) SWIG_fail;
30893 }
30894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30895 return resultobj;
30896 fail:
30897 return NULL;
30898 }
30899
30900
30901 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30902 PyObject *resultobj = 0;
30903 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30904 int arg2 ;
30905 wxDateSpan *result = 0 ;
30906 void *argp1 = 0 ;
30907 int res1 = 0 ;
30908 int val2 ;
30909 int ecode2 = 0 ;
30910 PyObject * obj0 = 0 ;
30911 PyObject * obj1 = 0 ;
30912 char * kwnames[] = {
30913 (char *) "self",(char *) "factor", NULL
30914 };
30915
30916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30918 if (!SWIG_IsOK(res1)) {
30919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30920 }
30921 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30922 ecode2 = SWIG_AsVal_int(obj1, &val2);
30923 if (!SWIG_IsOK(ecode2)) {
30924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30925 }
30926 arg2 = static_cast< int >(val2);
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 {
30930 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30931 result = (wxDateSpan *) &_result_ref;
30932 }
30933 wxPyEndAllowThreads(__tstate);
30934 if (PyErr_Occurred()) SWIG_fail;
30935 }
30936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30937 return resultobj;
30938 fail:
30939 return NULL;
30940 }
30941
30942
30943 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30944 PyObject *resultobj = 0;
30945 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30946 wxDateSpan *arg2 = 0 ;
30947 wxDateSpan *result = 0 ;
30948 void *argp1 = 0 ;
30949 int res1 = 0 ;
30950 void *argp2 = 0 ;
30951 int res2 = 0 ;
30952 PyObject * obj0 = 0 ;
30953 PyObject * obj1 = 0 ;
30954 char * kwnames[] = {
30955 (char *) "self",(char *) "other", NULL
30956 };
30957
30958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30960 if (!SWIG_IsOK(res1)) {
30961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30962 }
30963 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30964 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30965 if (!SWIG_IsOK(res2)) {
30966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30967 }
30968 if (!argp2) {
30969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30970 }
30971 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 {
30975 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30976 result = (wxDateSpan *) &_result_ref;
30977 }
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30982 return resultobj;
30983 fail:
30984 return NULL;
30985 }
30986
30987
30988 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30989 PyObject *resultobj = 0;
30990 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30991 wxDateSpan *arg2 = 0 ;
30992 wxDateSpan *result = 0 ;
30993 void *argp1 = 0 ;
30994 int res1 = 0 ;
30995 void *argp2 = 0 ;
30996 int res2 = 0 ;
30997 PyObject * obj0 = 0 ;
30998 PyObject * obj1 = 0 ;
30999 char * kwnames[] = {
31000 (char *) "self",(char *) "other", NULL
31001 };
31002
31003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31005 if (!SWIG_IsOK(res1)) {
31006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31007 }
31008 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31009 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31010 if (!SWIG_IsOK(res2)) {
31011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31012 }
31013 if (!argp2) {
31014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31015 }
31016 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31017 {
31018 PyThreadState* __tstate = wxPyBeginAllowThreads();
31019 {
31020 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31021 result = (wxDateSpan *) &_result_ref;
31022 }
31023 wxPyEndAllowThreads(__tstate);
31024 if (PyErr_Occurred()) SWIG_fail;
31025 }
31026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31027 return resultobj;
31028 fail:
31029 return NULL;
31030 }
31031
31032
31033 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31034 PyObject *resultobj = 0;
31035 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31036 wxDateSpan *result = 0 ;
31037 void *argp1 = 0 ;
31038 int res1 = 0 ;
31039 PyObject *swig_obj[1] ;
31040
31041 if (!args) SWIG_fail;
31042 swig_obj[0] = args;
31043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31044 if (!SWIG_IsOK(res1)) {
31045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31046 }
31047 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31048 {
31049 PyThreadState* __tstate = wxPyBeginAllowThreads();
31050 {
31051 wxDateSpan &_result_ref = (arg1)->operator -();
31052 result = (wxDateSpan *) &_result_ref;
31053 }
31054 wxPyEndAllowThreads(__tstate);
31055 if (PyErr_Occurred()) SWIG_fail;
31056 }
31057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31058 return resultobj;
31059 fail:
31060 return NULL;
31061 }
31062
31063
31064 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31065 PyObject *resultobj = 0;
31066 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31067 int arg2 ;
31068 wxDateSpan *result = 0 ;
31069 void *argp1 = 0 ;
31070 int res1 = 0 ;
31071 int val2 ;
31072 int ecode2 = 0 ;
31073 PyObject * obj0 = 0 ;
31074 PyObject * obj1 = 0 ;
31075 char * kwnames[] = {
31076 (char *) "self",(char *) "factor", NULL
31077 };
31078
31079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31081 if (!SWIG_IsOK(res1)) {
31082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31083 }
31084 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31085 ecode2 = SWIG_AsVal_int(obj1, &val2);
31086 if (!SWIG_IsOK(ecode2)) {
31087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31088 }
31089 arg2 = static_cast< int >(val2);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 {
31093 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31094 result = (wxDateSpan *) &_result_ref;
31095 }
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31100 return resultobj;
31101 fail:
31102 return NULL;
31103 }
31104
31105
31106 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31107 PyObject *resultobj = 0;
31108 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31109 wxDateSpan *arg2 = 0 ;
31110 wxDateSpan result;
31111 void *argp1 = 0 ;
31112 int res1 = 0 ;
31113 void *argp2 = 0 ;
31114 int res2 = 0 ;
31115 PyObject * obj0 = 0 ;
31116 PyObject * obj1 = 0 ;
31117 char * kwnames[] = {
31118 (char *) "self",(char *) "other", NULL
31119 };
31120
31121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31123 if (!SWIG_IsOK(res1)) {
31124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31125 }
31126 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31128 if (!SWIG_IsOK(res2)) {
31129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31130 }
31131 if (!argp2) {
31132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31133 }
31134 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31151 wxDateSpan *arg2 = 0 ;
31152 wxDateSpan result;
31153 void *argp1 = 0 ;
31154 int res1 = 0 ;
31155 void *argp2 = 0 ;
31156 int res2 = 0 ;
31157 PyObject * obj0 = 0 ;
31158 PyObject * obj1 = 0 ;
31159 char * kwnames[] = {
31160 (char *) "self",(char *) "other", NULL
31161 };
31162
31163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31165 if (!SWIG_IsOK(res1)) {
31166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31167 }
31168 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31170 if (!SWIG_IsOK(res2)) {
31171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31172 }
31173 if (!argp2) {
31174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31175 }
31176 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31177 {
31178 PyThreadState* __tstate = wxPyBeginAllowThreads();
31179 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31184 return resultobj;
31185 fail:
31186 return NULL;
31187 }
31188
31189
31190 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31191 PyObject *resultobj = 0;
31192 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31193 int arg2 ;
31194 wxDateSpan result;
31195 void *argp1 = 0 ;
31196 int res1 = 0 ;
31197 int val2 ;
31198 int ecode2 = 0 ;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char * kwnames[] = {
31202 (char *) "self",(char *) "n", NULL
31203 };
31204
31205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31207 if (!SWIG_IsOK(res1)) {
31208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31209 }
31210 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31211 ecode2 = SWIG_AsVal_int(obj1, &val2);
31212 if (!SWIG_IsOK(ecode2)) {
31213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31214 }
31215 arg2 = static_cast< int >(val2);
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 result = wxDateSpan___mul__(arg1,arg2);
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31223 return resultobj;
31224 fail:
31225 return NULL;
31226 }
31227
31228
31229 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31230 PyObject *resultobj = 0;
31231 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31232 int arg2 ;
31233 wxDateSpan result;
31234 void *argp1 = 0 ;
31235 int res1 = 0 ;
31236 int val2 ;
31237 int ecode2 = 0 ;
31238 PyObject * obj0 = 0 ;
31239 PyObject * obj1 = 0 ;
31240 char * kwnames[] = {
31241 (char *) "self",(char *) "n", NULL
31242 };
31243
31244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31246 if (!SWIG_IsOK(res1)) {
31247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31248 }
31249 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31250 ecode2 = SWIG_AsVal_int(obj1, &val2);
31251 if (!SWIG_IsOK(ecode2)) {
31252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31253 }
31254 arg2 = static_cast< int >(val2);
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 result = wxDateSpan___rmul__(arg1,arg2);
31258 wxPyEndAllowThreads(__tstate);
31259 if (PyErr_Occurred()) SWIG_fail;
31260 }
31261 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj = 0;
31270 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31271 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31272 bool result;
31273 void *argp1 = 0 ;
31274 int res1 = 0 ;
31275 void *argp2 = 0 ;
31276 int res2 = 0 ;
31277 PyObject * obj0 = 0 ;
31278 PyObject * obj1 = 0 ;
31279 char * kwnames[] = {
31280 (char *) "self",(char *) "other", NULL
31281 };
31282
31283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31285 if (!SWIG_IsOK(res1)) {
31286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31287 }
31288 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31289 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31290 if (!SWIG_IsOK(res2)) {
31291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31292 }
31293 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31294 {
31295 PyThreadState* __tstate = wxPyBeginAllowThreads();
31296 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 {
31301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31302 }
31303 return resultobj;
31304 fail:
31305 return NULL;
31306 }
31307
31308
31309 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31310 PyObject *resultobj = 0;
31311 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31312 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31313 bool result;
31314 void *argp1 = 0 ;
31315 int res1 = 0 ;
31316 void *argp2 = 0 ;
31317 int res2 = 0 ;
31318 PyObject * obj0 = 0 ;
31319 PyObject * obj1 = 0 ;
31320 char * kwnames[] = {
31321 (char *) "self",(char *) "other", NULL
31322 };
31323
31324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31326 if (!SWIG_IsOK(res1)) {
31327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31328 }
31329 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31331 if (!SWIG_IsOK(res2)) {
31332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31333 }
31334 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31335 {
31336 PyThreadState* __tstate = wxPyBeginAllowThreads();
31337 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 {
31342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31343 }
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31351 PyObject *obj;
31352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31353 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31354 return SWIG_Py_Void();
31355 }
31356
31357 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 return SWIG_Python_InitShadowInstance(args);
31359 }
31360
31361 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31362 PyObject *resultobj = 0;
31363 long result;
31364
31365 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31366 {
31367 PyThreadState* __tstate = wxPyBeginAllowThreads();
31368 result = (long)wxGetLocalTime();
31369 wxPyEndAllowThreads(__tstate);
31370 if (PyErr_Occurred()) SWIG_fail;
31371 }
31372 resultobj = SWIG_From_long(static_cast< long >(result));
31373 return resultobj;
31374 fail:
31375 return NULL;
31376 }
31377
31378
31379 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31380 PyObject *resultobj = 0;
31381 long result;
31382
31383 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 result = (long)wxGetUTCTime();
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 resultobj = SWIG_From_long(static_cast< long >(result));
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31398 PyObject *resultobj = 0;
31399 long result;
31400
31401 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31402 {
31403 PyThreadState* __tstate = wxPyBeginAllowThreads();
31404 result = (long)wxGetCurrentTime();
31405 wxPyEndAllowThreads(__tstate);
31406 if (PyErr_Occurred()) SWIG_fail;
31407 }
31408 resultobj = SWIG_From_long(static_cast< long >(result));
31409 return resultobj;
31410 fail:
31411 return NULL;
31412 }
31413
31414
31415 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31416 PyObject *resultobj = 0;
31417 wxLongLong result;
31418
31419 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31420 {
31421 PyThreadState* __tstate = wxPyBeginAllowThreads();
31422 result = wxGetLocalTimeMillis();
31423 wxPyEndAllowThreads(__tstate);
31424 if (PyErr_Occurred()) SWIG_fail;
31425 }
31426 {
31427 PyObject *hi, *lo, *shifter, *shifted;
31428 hi = PyLong_FromLong( (&result)->GetHi() );
31429 lo = PyLong_FromLong( (&result)->GetLo() );
31430 shifter = PyLong_FromLong(32);
31431 shifted = PyNumber_Lshift(hi, shifter);
31432 resultobj = PyNumber_Or(shifted, lo);
31433 Py_DECREF(hi);
31434 Py_DECREF(lo);
31435 Py_DECREF(shifter);
31436 Py_DECREF(shifted);
31437 }
31438 return resultobj;
31439 fail:
31440 return NULL;
31441 }
31442
31443
31444 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31445 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31446 return 1;
31447 }
31448
31449
31450 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31451 PyObject *pyobj = 0;
31452
31453 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31454 return pyobj;
31455 }
31456
31457
31458 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31459 PyObject *resultobj = 0;
31460 wxDataFormatId arg1 ;
31461 wxDataFormat *result = 0 ;
31462 int val1 ;
31463 int ecode1 = 0 ;
31464 PyObject * obj0 = 0 ;
31465 char * kwnames[] = {
31466 (char *) "type", NULL
31467 };
31468
31469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31470 ecode1 = SWIG_AsVal_int(obj0, &val1);
31471 if (!SWIG_IsOK(ecode1)) {
31472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31473 }
31474 arg1 = static_cast< wxDataFormatId >(val1);
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 result = (wxDataFormat *)new wxDataFormat(arg1);
31478 wxPyEndAllowThreads(__tstate);
31479 if (PyErr_Occurred()) SWIG_fail;
31480 }
31481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31482 return resultobj;
31483 fail:
31484 return NULL;
31485 }
31486
31487
31488 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31489 PyObject *resultobj = 0;
31490 wxString *arg1 = 0 ;
31491 wxDataFormat *result = 0 ;
31492 bool temp1 = false ;
31493 PyObject * obj0 = 0 ;
31494 char * kwnames[] = {
31495 (char *) "format", NULL
31496 };
31497
31498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31499 {
31500 arg1 = wxString_in_helper(obj0);
31501 if (arg1 == NULL) SWIG_fail;
31502 temp1 = true;
31503 }
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31511 {
31512 if (temp1)
31513 delete arg1;
31514 }
31515 return resultobj;
31516 fail:
31517 {
31518 if (temp1)
31519 delete arg1;
31520 }
31521 return NULL;
31522 }
31523
31524
31525 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31526 PyObject *resultobj = 0;
31527 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31528 void *argp1 = 0 ;
31529 int res1 = 0 ;
31530 PyObject *swig_obj[1] ;
31531
31532 if (!args) SWIG_fail;
31533 swig_obj[0] = args;
31534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31535 if (!SWIG_IsOK(res1)) {
31536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31537 }
31538 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 delete arg1;
31542
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 resultobj = SWIG_Py_Void();
31547 return resultobj;
31548 fail:
31549 return NULL;
31550 }
31551
31552
31553 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31554 PyObject *resultobj = 0;
31555 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31556 wxDataFormatId arg2 ;
31557 bool result;
31558 void *argp1 = 0 ;
31559 int res1 = 0 ;
31560 int val2 ;
31561 int ecode2 = 0 ;
31562
31563 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31565 if (!SWIG_IsOK(res1)) {
31566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31567 }
31568 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31569 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31570 if (!SWIG_IsOK(ecode2)) {
31571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31572 }
31573 arg2 = static_cast< wxDataFormatId >(val2);
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 {
31581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31582 }
31583 return resultobj;
31584 fail:
31585 return NULL;
31586 }
31587
31588
31589 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31590 PyObject *resultobj = 0;
31591 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31592 wxDataFormatId arg2 ;
31593 bool result;
31594 void *argp1 = 0 ;
31595 int res1 = 0 ;
31596 int val2 ;
31597 int ecode2 = 0 ;
31598
31599 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31601 if (!SWIG_IsOK(res1)) {
31602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31603 }
31604 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31605 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31606 if (!SWIG_IsOK(ecode2)) {
31607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31608 }
31609 arg2 = static_cast< wxDataFormatId >(val2);
31610 {
31611 PyThreadState* __tstate = wxPyBeginAllowThreads();
31612 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31613 wxPyEndAllowThreads(__tstate);
31614 if (PyErr_Occurred()) SWIG_fail;
31615 }
31616 {
31617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31618 }
31619 return resultobj;
31620 fail:
31621 return NULL;
31622 }
31623
31624
31625 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31626 PyObject *resultobj = 0;
31627 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31628 wxDataFormat *arg2 = 0 ;
31629 bool result;
31630 void *argp1 = 0 ;
31631 int res1 = 0 ;
31632 void *argp2 = 0 ;
31633 int res2 = 0 ;
31634
31635 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31637 if (!SWIG_IsOK(res1)) {
31638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31639 }
31640 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31641 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31642 if (!SWIG_IsOK(res2)) {
31643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31644 }
31645 if (!argp2) {
31646 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31647 }
31648 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31649 {
31650 PyThreadState* __tstate = wxPyBeginAllowThreads();
31651 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31652 wxPyEndAllowThreads(__tstate);
31653 if (PyErr_Occurred()) SWIG_fail;
31654 }
31655 {
31656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31657 }
31658 return resultobj;
31659 fail:
31660 return NULL;
31661 }
31662
31663
31664 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31665 int argc;
31666 PyObject *argv[3];
31667
31668 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31669 --argc;
31670 if (argc == 2) {
31671 int _v = 0;
31672 {
31673 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31674 _v = SWIG_CheckState(res);
31675 }
31676 if (!_v) goto check_1;
31677 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31678 }
31679 check_1:
31680
31681 if (argc == 2) {
31682 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31683 }
31684
31685 fail:
31686 Py_INCREF(Py_NotImplemented);
31687 return Py_NotImplemented;
31688 }
31689
31690
31691 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31692 PyObject *resultobj = 0;
31693 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31694 wxDataFormat *arg2 = 0 ;
31695 bool result;
31696 void *argp1 = 0 ;
31697 int res1 = 0 ;
31698 void *argp2 = 0 ;
31699 int res2 = 0 ;
31700
31701 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31705 }
31706 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31707 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31708 if (!SWIG_IsOK(res2)) {
31709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31710 }
31711 if (!argp2) {
31712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31713 }
31714 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31715 {
31716 PyThreadState* __tstate = wxPyBeginAllowThreads();
31717 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31718 wxPyEndAllowThreads(__tstate);
31719 if (PyErr_Occurred()) SWIG_fail;
31720 }
31721 {
31722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31723 }
31724 return resultobj;
31725 fail:
31726 return NULL;
31727 }
31728
31729
31730 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31731 int argc;
31732 PyObject *argv[3];
31733
31734 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31735 --argc;
31736 if (argc == 2) {
31737 int _v = 0;
31738 {
31739 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31740 _v = SWIG_CheckState(res);
31741 }
31742 if (!_v) goto check_1;
31743 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31744 }
31745 check_1:
31746
31747 if (argc == 2) {
31748 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31749 }
31750
31751 fail:
31752 Py_INCREF(Py_NotImplemented);
31753 return Py_NotImplemented;
31754 }
31755
31756
31757 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31758 PyObject *resultobj = 0;
31759 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31760 wxDataFormatId arg2 ;
31761 void *argp1 = 0 ;
31762 int res1 = 0 ;
31763 int val2 ;
31764 int ecode2 = 0 ;
31765 PyObject * obj0 = 0 ;
31766 PyObject * obj1 = 0 ;
31767 char * kwnames[] = {
31768 (char *) "self",(char *) "format", NULL
31769 };
31770
31771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31773 if (!SWIG_IsOK(res1)) {
31774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31775 }
31776 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31777 ecode2 = SWIG_AsVal_int(obj1, &val2);
31778 if (!SWIG_IsOK(ecode2)) {
31779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31780 }
31781 arg2 = static_cast< wxDataFormatId >(val2);
31782 {
31783 PyThreadState* __tstate = wxPyBeginAllowThreads();
31784 (arg1)->SetType(arg2);
31785 wxPyEndAllowThreads(__tstate);
31786 if (PyErr_Occurred()) SWIG_fail;
31787 }
31788 resultobj = SWIG_Py_Void();
31789 return resultobj;
31790 fail:
31791 return NULL;
31792 }
31793
31794
31795 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31796 PyObject *resultobj = 0;
31797 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31798 wxDataFormatId result;
31799 void *argp1 = 0 ;
31800 int res1 = 0 ;
31801 PyObject *swig_obj[1] ;
31802
31803 if (!args) SWIG_fail;
31804 swig_obj[0] = args;
31805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31808 }
31809 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_From_int(static_cast< int >(result));
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31824 PyObject *resultobj = 0;
31825 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31826 wxString result;
31827 void *argp1 = 0 ;
31828 int res1 = 0 ;
31829 PyObject *swig_obj[1] ;
31830
31831 if (!args) SWIG_fail;
31832 swig_obj[0] = args;
31833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31836 }
31837 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 result = ((wxDataFormat const *)arg1)->GetId();
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 {
31845 #if wxUSE_UNICODE
31846 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31847 #else
31848 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31849 #endif
31850 }
31851 return resultobj;
31852 fail:
31853 return NULL;
31854 }
31855
31856
31857 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31858 PyObject *resultobj = 0;
31859 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31860 wxString *arg2 = 0 ;
31861 void *argp1 = 0 ;
31862 int res1 = 0 ;
31863 bool temp2 = false ;
31864 PyObject * obj0 = 0 ;
31865 PyObject * obj1 = 0 ;
31866 char * kwnames[] = {
31867 (char *) "self",(char *) "format", NULL
31868 };
31869
31870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31872 if (!SWIG_IsOK(res1)) {
31873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31874 }
31875 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31876 {
31877 arg2 = wxString_in_helper(obj1);
31878 if (arg2 == NULL) SWIG_fail;
31879 temp2 = true;
31880 }
31881 {
31882 PyThreadState* __tstate = wxPyBeginAllowThreads();
31883 (arg1)->SetId((wxString const &)*arg2);
31884 wxPyEndAllowThreads(__tstate);
31885 if (PyErr_Occurred()) SWIG_fail;
31886 }
31887 resultobj = SWIG_Py_Void();
31888 {
31889 if (temp2)
31890 delete arg2;
31891 }
31892 return resultobj;
31893 fail:
31894 {
31895 if (temp2)
31896 delete arg2;
31897 }
31898 return NULL;
31899 }
31900
31901
31902 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31903 PyObject *obj;
31904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31905 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31906 return SWIG_Py_Void();
31907 }
31908
31909 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31910 return SWIG_Python_InitShadowInstance(args);
31911 }
31912
31913 SWIGINTERN int FormatInvalid_set(PyObject *) {
31914 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31915 return 1;
31916 }
31917
31918
31919 SWIGINTERN PyObject *FormatInvalid_get(void) {
31920 PyObject *pyobj = 0;
31921
31922 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31923 return pyobj;
31924 }
31925
31926
31927 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31928 PyObject *resultobj = 0;
31929 wxDataObject *arg1 = (wxDataObject *) 0 ;
31930 void *argp1 = 0 ;
31931 int res1 = 0 ;
31932 PyObject *swig_obj[1] ;
31933
31934 if (!args) SWIG_fail;
31935 swig_obj[0] = args;
31936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31937 if (!SWIG_IsOK(res1)) {
31938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31939 }
31940 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 delete arg1;
31944
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 resultobj = SWIG_Py_Void();
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31956 PyObject *resultobj = 0;
31957 wxDataObject *arg1 = (wxDataObject *) 0 ;
31958 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31959 SwigValueWrapper<wxDataFormat > result;
31960 void *argp1 = 0 ;
31961 int res1 = 0 ;
31962 int val2 ;
31963 int ecode2 = 0 ;
31964 PyObject * obj0 = 0 ;
31965 PyObject * obj1 = 0 ;
31966 char * kwnames[] = {
31967 (char *) "self",(char *) "dir", NULL
31968 };
31969
31970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31972 if (!SWIG_IsOK(res1)) {
31973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31974 }
31975 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31976 if (obj1) {
31977 ecode2 = SWIG_AsVal_int(obj1, &val2);
31978 if (!SWIG_IsOK(ecode2)) {
31979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31980 }
31981 arg2 = static_cast< wxDataObject::Direction >(val2);
31982 }
31983 {
31984 PyThreadState* __tstate = wxPyBeginAllowThreads();
31985 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31986 wxPyEndAllowThreads(__tstate);
31987 if (PyErr_Occurred()) SWIG_fail;
31988 }
31989 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31990 return resultobj;
31991 fail:
31992 return NULL;
31993 }
31994
31995
31996 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31997 PyObject *resultobj = 0;
31998 wxDataObject *arg1 = (wxDataObject *) 0 ;
31999 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32000 size_t result;
32001 void *argp1 = 0 ;
32002 int res1 = 0 ;
32003 int val2 ;
32004 int ecode2 = 0 ;
32005 PyObject * obj0 = 0 ;
32006 PyObject * obj1 = 0 ;
32007 char * kwnames[] = {
32008 (char *) "self",(char *) "dir", NULL
32009 };
32010
32011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32015 }
32016 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32017 if (obj1) {
32018 ecode2 = SWIG_AsVal_int(obj1, &val2);
32019 if (!SWIG_IsOK(ecode2)) {
32020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32021 }
32022 arg2 = static_cast< wxDataObject::Direction >(val2);
32023 }
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32038 PyObject *resultobj = 0;
32039 wxDataObject *arg1 = (wxDataObject *) 0 ;
32040 wxDataFormat *arg2 = 0 ;
32041 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32042 bool result;
32043 void *argp1 = 0 ;
32044 int res1 = 0 ;
32045 void *argp2 = 0 ;
32046 int res2 = 0 ;
32047 int val3 ;
32048 int ecode3 = 0 ;
32049 PyObject * obj0 = 0 ;
32050 PyObject * obj1 = 0 ;
32051 PyObject * obj2 = 0 ;
32052 char * kwnames[] = {
32053 (char *) "self",(char *) "format",(char *) "dir", NULL
32054 };
32055
32056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32058 if (!SWIG_IsOK(res1)) {
32059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32060 }
32061 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32062 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32063 if (!SWIG_IsOK(res2)) {
32064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32065 }
32066 if (!argp2) {
32067 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32068 }
32069 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32070 if (obj2) {
32071 ecode3 = SWIG_AsVal_int(obj2, &val3);
32072 if (!SWIG_IsOK(ecode3)) {
32073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32074 }
32075 arg3 = static_cast< wxDataObject::Direction >(val3);
32076 }
32077 {
32078 PyThreadState* __tstate = wxPyBeginAllowThreads();
32079 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32080 wxPyEndAllowThreads(__tstate);
32081 if (PyErr_Occurred()) SWIG_fail;
32082 }
32083 {
32084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32085 }
32086 return resultobj;
32087 fail:
32088 return NULL;
32089 }
32090
32091
32092 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32093 PyObject *resultobj = 0;
32094 wxDataObject *arg1 = (wxDataObject *) 0 ;
32095 wxDataFormat *arg2 = 0 ;
32096 size_t result;
32097 void *argp1 = 0 ;
32098 int res1 = 0 ;
32099 void *argp2 = 0 ;
32100 int res2 = 0 ;
32101 PyObject * obj0 = 0 ;
32102 PyObject * obj1 = 0 ;
32103 char * kwnames[] = {
32104 (char *) "self",(char *) "format", NULL
32105 };
32106
32107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32109 if (!SWIG_IsOK(res1)) {
32110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32111 }
32112 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32114 if (!SWIG_IsOK(res2)) {
32115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32116 }
32117 if (!argp2) {
32118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32119 }
32120 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32128 return resultobj;
32129 fail:
32130 return NULL;
32131 }
32132
32133
32134 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32135 PyObject *resultobj = 0;
32136 wxDataObject *arg1 = (wxDataObject *) 0 ;
32137 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32138 PyObject *result = 0 ;
32139 void *argp1 = 0 ;
32140 int res1 = 0 ;
32141 int val2 ;
32142 int ecode2 = 0 ;
32143 PyObject * obj0 = 0 ;
32144 PyObject * obj1 = 0 ;
32145 char * kwnames[] = {
32146 (char *) "self",(char *) "dir", NULL
32147 };
32148
32149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32151 if (!SWIG_IsOK(res1)) {
32152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32153 }
32154 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32155 if (obj1) {
32156 ecode2 = SWIG_AsVal_int(obj1, &val2);
32157 if (!SWIG_IsOK(ecode2)) {
32158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32159 }
32160 arg2 = static_cast< wxDataObject::Direction >(val2);
32161 }
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 resultobj = result;
32169 return resultobj;
32170 fail:
32171 return NULL;
32172 }
32173
32174
32175 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32176 PyObject *resultobj = 0;
32177 wxDataObject *arg1 = (wxDataObject *) 0 ;
32178 wxDataFormat *arg2 = 0 ;
32179 PyObject *result = 0 ;
32180 void *argp1 = 0 ;
32181 int res1 = 0 ;
32182 void *argp2 = 0 ;
32183 int res2 = 0 ;
32184 PyObject * obj0 = 0 ;
32185 PyObject * obj1 = 0 ;
32186 char * kwnames[] = {
32187 (char *) "self",(char *) "format", NULL
32188 };
32189
32190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32192 if (!SWIG_IsOK(res1)) {
32193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32194 }
32195 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32197 if (!SWIG_IsOK(res2)) {
32198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32199 }
32200 if (!argp2) {
32201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32202 }
32203 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32204 {
32205 PyThreadState* __tstate = wxPyBeginAllowThreads();
32206 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32207 wxPyEndAllowThreads(__tstate);
32208 if (PyErr_Occurred()) SWIG_fail;
32209 }
32210 resultobj = result;
32211 return resultobj;
32212 fail:
32213 return NULL;
32214 }
32215
32216
32217 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32218 PyObject *resultobj = 0;
32219 wxDataObject *arg1 = (wxDataObject *) 0 ;
32220 wxDataFormat *arg2 = 0 ;
32221 PyObject *arg3 = (PyObject *) 0 ;
32222 bool result;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 void *argp2 = 0 ;
32226 int res2 = 0 ;
32227 PyObject * obj0 = 0 ;
32228 PyObject * obj1 = 0 ;
32229 PyObject * obj2 = 0 ;
32230 char * kwnames[] = {
32231 (char *) "self",(char *) "format",(char *) "data", NULL
32232 };
32233
32234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32236 if (!SWIG_IsOK(res1)) {
32237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32238 }
32239 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32240 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32241 if (!SWIG_IsOK(res2)) {
32242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32243 }
32244 if (!argp2) {
32245 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32246 }
32247 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32248 arg3 = obj2;
32249 {
32250 PyThreadState* __tstate = wxPyBeginAllowThreads();
32251 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32252 wxPyEndAllowThreads(__tstate);
32253 if (PyErr_Occurred()) SWIG_fail;
32254 }
32255 {
32256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32257 }
32258 return resultobj;
32259 fail:
32260 return NULL;
32261 }
32262
32263
32264 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32265 PyObject *obj;
32266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32267 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32268 return SWIG_Py_Void();
32269 }
32270
32271 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32272 PyObject *resultobj = 0;
32273 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32274 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32275 wxDataObjectSimple *result = 0 ;
32276 void *argp1 = 0 ;
32277 int res1 = 0 ;
32278 PyObject * obj0 = 0 ;
32279 char * kwnames[] = {
32280 (char *) "format", NULL
32281 };
32282
32283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32284 if (obj0) {
32285 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32286 if (!SWIG_IsOK(res1)) {
32287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32288 }
32289 if (!argp1) {
32290 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32291 }
32292 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32293 }
32294 {
32295 PyThreadState* __tstate = wxPyBeginAllowThreads();
32296 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32297 wxPyEndAllowThreads(__tstate);
32298 if (PyErr_Occurred()) SWIG_fail;
32299 }
32300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32301 return resultobj;
32302 fail:
32303 return NULL;
32304 }
32305
32306
32307 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32308 PyObject *resultobj = 0;
32309 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32310 wxDataFormat *result = 0 ;
32311 void *argp1 = 0 ;
32312 int res1 = 0 ;
32313 PyObject *swig_obj[1] ;
32314
32315 if (!args) SWIG_fail;
32316 swig_obj[0] = args;
32317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32318 if (!SWIG_IsOK(res1)) {
32319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32320 }
32321 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32322 {
32323 PyThreadState* __tstate = wxPyBeginAllowThreads();
32324 {
32325 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32326 result = (wxDataFormat *) &_result_ref;
32327 }
32328 wxPyEndAllowThreads(__tstate);
32329 if (PyErr_Occurred()) SWIG_fail;
32330 }
32331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32332 return resultobj;
32333 fail:
32334 return NULL;
32335 }
32336
32337
32338 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32339 PyObject *resultobj = 0;
32340 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32341 wxDataFormat *arg2 = 0 ;
32342 void *argp1 = 0 ;
32343 int res1 = 0 ;
32344 void *argp2 = 0 ;
32345 int res2 = 0 ;
32346 PyObject * obj0 = 0 ;
32347 PyObject * obj1 = 0 ;
32348 char * kwnames[] = {
32349 (char *) "self",(char *) "format", NULL
32350 };
32351
32352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32354 if (!SWIG_IsOK(res1)) {
32355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32356 }
32357 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32358 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32359 if (!SWIG_IsOK(res2)) {
32360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32361 }
32362 if (!argp2) {
32363 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32364 }
32365 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 resultobj = SWIG_Py_Void();
32373 return resultobj;
32374 fail:
32375 return NULL;
32376 }
32377
32378
32379 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 PyObject *resultobj = 0;
32381 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32382 size_t result;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 PyObject *swig_obj[1] ;
32386
32387 if (!args) SWIG_fail;
32388 swig_obj[0] = args;
32389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32390 if (!SWIG_IsOK(res1)) {
32391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32392 }
32393 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32394 {
32395 PyThreadState* __tstate = wxPyBeginAllowThreads();
32396 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32397 wxPyEndAllowThreads(__tstate);
32398 if (PyErr_Occurred()) SWIG_fail;
32399 }
32400 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32401 return resultobj;
32402 fail:
32403 return NULL;
32404 }
32405
32406
32407 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32408 PyObject *resultobj = 0;
32409 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32410 PyObject *result = 0 ;
32411 void *argp1 = 0 ;
32412 int res1 = 0 ;
32413 PyObject *swig_obj[1] ;
32414
32415 if (!args) SWIG_fail;
32416 swig_obj[0] = args;
32417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32418 if (!SWIG_IsOK(res1)) {
32419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32420 }
32421 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32422 {
32423 PyThreadState* __tstate = wxPyBeginAllowThreads();
32424 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32425 wxPyEndAllowThreads(__tstate);
32426 if (PyErr_Occurred()) SWIG_fail;
32427 }
32428 resultobj = result;
32429 return resultobj;
32430 fail:
32431 return NULL;
32432 }
32433
32434
32435 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32436 PyObject *resultobj = 0;
32437 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32438 PyObject *arg2 = (PyObject *) 0 ;
32439 bool result;
32440 void *argp1 = 0 ;
32441 int res1 = 0 ;
32442 PyObject * obj0 = 0 ;
32443 PyObject * obj1 = 0 ;
32444 char * kwnames[] = {
32445 (char *) "self",(char *) "data", NULL
32446 };
32447
32448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32450 if (!SWIG_IsOK(res1)) {
32451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32452 }
32453 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32454 arg2 = obj1;
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32458 wxPyEndAllowThreads(__tstate);
32459 if (PyErr_Occurred()) SWIG_fail;
32460 }
32461 {
32462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32463 }
32464 return resultobj;
32465 fail:
32466 return NULL;
32467 }
32468
32469
32470 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32471 PyObject *obj;
32472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32473 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32474 return SWIG_Py_Void();
32475 }
32476
32477 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32478 return SWIG_Python_InitShadowInstance(args);
32479 }
32480
32481 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32482 PyObject *resultobj = 0;
32483 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32484 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32485 wxPyDataObjectSimple *result = 0 ;
32486 void *argp1 = 0 ;
32487 int res1 = 0 ;
32488 PyObject * obj0 = 0 ;
32489 char * kwnames[] = {
32490 (char *) "format", NULL
32491 };
32492
32493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32494 if (obj0) {
32495 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32496 if (!SWIG_IsOK(res1)) {
32497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32498 }
32499 if (!argp1) {
32500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32501 }
32502 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32503 }
32504 {
32505 PyThreadState* __tstate = wxPyBeginAllowThreads();
32506 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32507 wxPyEndAllowThreads(__tstate);
32508 if (PyErr_Occurred()) SWIG_fail;
32509 }
32510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32511 return resultobj;
32512 fail:
32513 return NULL;
32514 }
32515
32516
32517 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32518 PyObject *resultobj = 0;
32519 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32520 PyObject *arg2 = (PyObject *) 0 ;
32521 PyObject *arg3 = (PyObject *) 0 ;
32522 void *argp1 = 0 ;
32523 int res1 = 0 ;
32524 PyObject * obj0 = 0 ;
32525 PyObject * obj1 = 0 ;
32526 PyObject * obj2 = 0 ;
32527 char * kwnames[] = {
32528 (char *) "self",(char *) "self",(char *) "_class", NULL
32529 };
32530
32531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32533 if (!SWIG_IsOK(res1)) {
32534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32535 }
32536 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32537 arg2 = obj1;
32538 arg3 = obj2;
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 (arg1)->_setCallbackInfo(arg2,arg3);
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 resultobj = SWIG_Py_Void();
32546 return resultobj;
32547 fail:
32548 return NULL;
32549 }
32550
32551
32552 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32553 PyObject *obj;
32554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32555 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32556 return SWIG_Py_Void();
32557 }
32558
32559 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32560 return SWIG_Python_InitShadowInstance(args);
32561 }
32562
32563 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32564 PyObject *resultobj = 0;
32565 wxDataObjectComposite *result = 0 ;
32566
32567 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32568 {
32569 PyThreadState* __tstate = wxPyBeginAllowThreads();
32570 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32571 wxPyEndAllowThreads(__tstate);
32572 if (PyErr_Occurred()) SWIG_fail;
32573 }
32574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32575 return resultobj;
32576 fail:
32577 return NULL;
32578 }
32579
32580
32581 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32582 PyObject *resultobj = 0;
32583 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32584 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32585 bool arg3 = (bool) false ;
32586 void *argp1 = 0 ;
32587 int res1 = 0 ;
32588 int res2 = 0 ;
32589 bool val3 ;
32590 int ecode3 = 0 ;
32591 PyObject * obj0 = 0 ;
32592 PyObject * obj1 = 0 ;
32593 PyObject * obj2 = 0 ;
32594 char * kwnames[] = {
32595 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32596 };
32597
32598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32600 if (!SWIG_IsOK(res1)) {
32601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32602 }
32603 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32604 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32605 if (!SWIG_IsOK(res2)) {
32606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32607 }
32608 if (obj2) {
32609 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32610 if (!SWIG_IsOK(ecode3)) {
32611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32612 }
32613 arg3 = static_cast< bool >(val3);
32614 }
32615 {
32616 PyThreadState* __tstate = wxPyBeginAllowThreads();
32617 (arg1)->Add(arg2,arg3);
32618 wxPyEndAllowThreads(__tstate);
32619 if (PyErr_Occurred()) SWIG_fail;
32620 }
32621 resultobj = SWIG_Py_Void();
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32629 PyObject *resultobj = 0;
32630 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32631 SwigValueWrapper<wxDataFormat > result;
32632 void *argp1 = 0 ;
32633 int res1 = 0 ;
32634 PyObject *swig_obj[1] ;
32635
32636 if (!args) SWIG_fail;
32637 swig_obj[0] = args;
32638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32639 if (!SWIG_IsOK(res1)) {
32640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32641 }
32642 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32643 {
32644 PyThreadState* __tstate = wxPyBeginAllowThreads();
32645 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32646 wxPyEndAllowThreads(__tstate);
32647 if (PyErr_Occurred()) SWIG_fail;
32648 }
32649 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32650 return resultobj;
32651 fail:
32652 return NULL;
32653 }
32654
32655
32656 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32657 PyObject *obj;
32658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32659 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32660 return SWIG_Py_Void();
32661 }
32662
32663 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32664 return SWIG_Python_InitShadowInstance(args);
32665 }
32666
32667 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32668 PyObject *resultobj = 0;
32669 wxString const &arg1_defvalue = wxPyEmptyString ;
32670 wxString *arg1 = (wxString *) &arg1_defvalue ;
32671 wxTextDataObject *result = 0 ;
32672 bool temp1 = false ;
32673 PyObject * obj0 = 0 ;
32674 char * kwnames[] = {
32675 (char *) "text", NULL
32676 };
32677
32678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32679 if (obj0) {
32680 {
32681 arg1 = wxString_in_helper(obj0);
32682 if (arg1 == NULL) SWIG_fail;
32683 temp1 = true;
32684 }
32685 }
32686 {
32687 PyThreadState* __tstate = wxPyBeginAllowThreads();
32688 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32689 wxPyEndAllowThreads(__tstate);
32690 if (PyErr_Occurred()) SWIG_fail;
32691 }
32692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32693 {
32694 if (temp1)
32695 delete arg1;
32696 }
32697 return resultobj;
32698 fail:
32699 {
32700 if (temp1)
32701 delete arg1;
32702 }
32703 return NULL;
32704 }
32705
32706
32707 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32708 PyObject *resultobj = 0;
32709 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32710 size_t result;
32711 void *argp1 = 0 ;
32712 int res1 = 0 ;
32713 PyObject *swig_obj[1] ;
32714
32715 if (!args) SWIG_fail;
32716 swig_obj[0] = args;
32717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32718 if (!SWIG_IsOK(res1)) {
32719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32720 }
32721 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32722 {
32723 PyThreadState* __tstate = wxPyBeginAllowThreads();
32724 result = (size_t)(arg1)->GetTextLength();
32725 wxPyEndAllowThreads(__tstate);
32726 if (PyErr_Occurred()) SWIG_fail;
32727 }
32728 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32729 return resultobj;
32730 fail:
32731 return NULL;
32732 }
32733
32734
32735 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32736 PyObject *resultobj = 0;
32737 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32738 wxString result;
32739 void *argp1 = 0 ;
32740 int res1 = 0 ;
32741 PyObject *swig_obj[1] ;
32742
32743 if (!args) SWIG_fail;
32744 swig_obj[0] = args;
32745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32746 if (!SWIG_IsOK(res1)) {
32747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32748 }
32749 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 result = (arg1)->GetText();
32753 wxPyEndAllowThreads(__tstate);
32754 if (PyErr_Occurred()) SWIG_fail;
32755 }
32756 {
32757 #if wxUSE_UNICODE
32758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32759 #else
32760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32761 #endif
32762 }
32763 return resultobj;
32764 fail:
32765 return NULL;
32766 }
32767
32768
32769 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32770 PyObject *resultobj = 0;
32771 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32772 wxString *arg2 = 0 ;
32773 void *argp1 = 0 ;
32774 int res1 = 0 ;
32775 bool temp2 = false ;
32776 PyObject * obj0 = 0 ;
32777 PyObject * obj1 = 0 ;
32778 char * kwnames[] = {
32779 (char *) "self",(char *) "text", NULL
32780 };
32781
32782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32784 if (!SWIG_IsOK(res1)) {
32785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32786 }
32787 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32788 {
32789 arg2 = wxString_in_helper(obj1);
32790 if (arg2 == NULL) SWIG_fail;
32791 temp2 = true;
32792 }
32793 {
32794 PyThreadState* __tstate = wxPyBeginAllowThreads();
32795 (arg1)->SetText((wxString const &)*arg2);
32796 wxPyEndAllowThreads(__tstate);
32797 if (PyErr_Occurred()) SWIG_fail;
32798 }
32799 resultobj = SWIG_Py_Void();
32800 {
32801 if (temp2)
32802 delete arg2;
32803 }
32804 return resultobj;
32805 fail:
32806 {
32807 if (temp2)
32808 delete arg2;
32809 }
32810 return NULL;
32811 }
32812
32813
32814 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32815 PyObject *obj;
32816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32817 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32818 return SWIG_Py_Void();
32819 }
32820
32821 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32822 return SWIG_Python_InitShadowInstance(args);
32823 }
32824
32825 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32826 PyObject *resultobj = 0;
32827 wxString const &arg1_defvalue = wxPyEmptyString ;
32828 wxString *arg1 = (wxString *) &arg1_defvalue ;
32829 wxPyTextDataObject *result = 0 ;
32830 bool temp1 = false ;
32831 PyObject * obj0 = 0 ;
32832 char * kwnames[] = {
32833 (char *) "text", NULL
32834 };
32835
32836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32837 if (obj0) {
32838 {
32839 arg1 = wxString_in_helper(obj0);
32840 if (arg1 == NULL) SWIG_fail;
32841 temp1 = true;
32842 }
32843 }
32844 {
32845 PyThreadState* __tstate = wxPyBeginAllowThreads();
32846 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32847 wxPyEndAllowThreads(__tstate);
32848 if (PyErr_Occurred()) SWIG_fail;
32849 }
32850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32851 {
32852 if (temp1)
32853 delete arg1;
32854 }
32855 return resultobj;
32856 fail:
32857 {
32858 if (temp1)
32859 delete arg1;
32860 }
32861 return NULL;
32862 }
32863
32864
32865 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32866 PyObject *resultobj = 0;
32867 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32868 PyObject *arg2 = (PyObject *) 0 ;
32869 PyObject *arg3 = (PyObject *) 0 ;
32870 void *argp1 = 0 ;
32871 int res1 = 0 ;
32872 PyObject * obj0 = 0 ;
32873 PyObject * obj1 = 0 ;
32874 PyObject * obj2 = 0 ;
32875 char * kwnames[] = {
32876 (char *) "self",(char *) "self",(char *) "_class", NULL
32877 };
32878
32879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32881 if (!SWIG_IsOK(res1)) {
32882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32883 }
32884 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32885 arg2 = obj1;
32886 arg3 = obj2;
32887 {
32888 PyThreadState* __tstate = wxPyBeginAllowThreads();
32889 (arg1)->_setCallbackInfo(arg2,arg3);
32890 wxPyEndAllowThreads(__tstate);
32891 if (PyErr_Occurred()) SWIG_fail;
32892 }
32893 resultobj = SWIG_Py_Void();
32894 return resultobj;
32895 fail:
32896 return NULL;
32897 }
32898
32899
32900 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32901 PyObject *obj;
32902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32903 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32904 return SWIG_Py_Void();
32905 }
32906
32907 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32908 return SWIG_Python_InitShadowInstance(args);
32909 }
32910
32911 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32912 PyObject *resultobj = 0;
32913 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32914 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32915 wxBitmapDataObject *result = 0 ;
32916 void *argp1 = 0 ;
32917 int res1 = 0 ;
32918 PyObject * obj0 = 0 ;
32919 char * kwnames[] = {
32920 (char *) "bitmap", NULL
32921 };
32922
32923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32924 if (obj0) {
32925 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32926 if (!SWIG_IsOK(res1)) {
32927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32928 }
32929 if (!argp1) {
32930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32931 }
32932 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32933 }
32934 {
32935 PyThreadState* __tstate = wxPyBeginAllowThreads();
32936 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32937 wxPyEndAllowThreads(__tstate);
32938 if (PyErr_Occurred()) SWIG_fail;
32939 }
32940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32941 return resultobj;
32942 fail:
32943 return NULL;
32944 }
32945
32946
32947 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32948 PyObject *resultobj = 0;
32949 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32950 wxBitmap result;
32951 void *argp1 = 0 ;
32952 int res1 = 0 ;
32953 PyObject *swig_obj[1] ;
32954
32955 if (!args) SWIG_fail;
32956 swig_obj[0] = args;
32957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32958 if (!SWIG_IsOK(res1)) {
32959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32960 }
32961 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32962 {
32963 PyThreadState* __tstate = wxPyBeginAllowThreads();
32964 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32965 wxPyEndAllowThreads(__tstate);
32966 if (PyErr_Occurred()) SWIG_fail;
32967 }
32968 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32969 return resultobj;
32970 fail:
32971 return NULL;
32972 }
32973
32974
32975 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32976 PyObject *resultobj = 0;
32977 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32978 wxBitmap *arg2 = 0 ;
32979 void *argp1 = 0 ;
32980 int res1 = 0 ;
32981 void *argp2 = 0 ;
32982 int res2 = 0 ;
32983 PyObject * obj0 = 0 ;
32984 PyObject * obj1 = 0 ;
32985 char * kwnames[] = {
32986 (char *) "self",(char *) "bitmap", NULL
32987 };
32988
32989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32991 if (!SWIG_IsOK(res1)) {
32992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32993 }
32994 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32995 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32996 if (!SWIG_IsOK(res2)) {
32997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32998 }
32999 if (!argp2) {
33000 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33001 }
33002 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33003 {
33004 PyThreadState* __tstate = wxPyBeginAllowThreads();
33005 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33006 wxPyEndAllowThreads(__tstate);
33007 if (PyErr_Occurred()) SWIG_fail;
33008 }
33009 resultobj = SWIG_Py_Void();
33010 return resultobj;
33011 fail:
33012 return NULL;
33013 }
33014
33015
33016 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33017 PyObject *obj;
33018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33019 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33020 return SWIG_Py_Void();
33021 }
33022
33023 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33024 return SWIG_Python_InitShadowInstance(args);
33025 }
33026
33027 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33028 PyObject *resultobj = 0;
33029 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33030 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33031 wxPyBitmapDataObject *result = 0 ;
33032 void *argp1 = 0 ;
33033 int res1 = 0 ;
33034 PyObject * obj0 = 0 ;
33035 char * kwnames[] = {
33036 (char *) "bitmap", NULL
33037 };
33038
33039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33040 if (obj0) {
33041 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33042 if (!SWIG_IsOK(res1)) {
33043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33044 }
33045 if (!argp1) {
33046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33047 }
33048 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33049 }
33050 {
33051 PyThreadState* __tstate = wxPyBeginAllowThreads();
33052 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33053 wxPyEndAllowThreads(__tstate);
33054 if (PyErr_Occurred()) SWIG_fail;
33055 }
33056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33057 return resultobj;
33058 fail:
33059 return NULL;
33060 }
33061
33062
33063 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33064 PyObject *resultobj = 0;
33065 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33066 PyObject *arg2 = (PyObject *) 0 ;
33067 PyObject *arg3 = (PyObject *) 0 ;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 PyObject * obj0 = 0 ;
33071 PyObject * obj1 = 0 ;
33072 PyObject * obj2 = 0 ;
33073 char * kwnames[] = {
33074 (char *) "self",(char *) "self",(char *) "_class", NULL
33075 };
33076
33077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33081 }
33082 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33083 arg2 = obj1;
33084 arg3 = obj2;
33085 {
33086 PyThreadState* __tstate = wxPyBeginAllowThreads();
33087 (arg1)->_setCallbackInfo(arg2,arg3);
33088 wxPyEndAllowThreads(__tstate);
33089 if (PyErr_Occurred()) SWIG_fail;
33090 }
33091 resultobj = SWIG_Py_Void();
33092 return resultobj;
33093 fail:
33094 return NULL;
33095 }
33096
33097
33098 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33099 PyObject *obj;
33100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33101 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33102 return SWIG_Py_Void();
33103 }
33104
33105 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33106 return SWIG_Python_InitShadowInstance(args);
33107 }
33108
33109 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33110 PyObject *resultobj = 0;
33111 wxFileDataObject *result = 0 ;
33112
33113 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33114 {
33115 PyThreadState* __tstate = wxPyBeginAllowThreads();
33116 result = (wxFileDataObject *)new wxFileDataObject();
33117 wxPyEndAllowThreads(__tstate);
33118 if (PyErr_Occurred()) SWIG_fail;
33119 }
33120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33121 return resultobj;
33122 fail:
33123 return NULL;
33124 }
33125
33126
33127 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33128 PyObject *resultobj = 0;
33129 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33130 wxArrayString *result = 0 ;
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_wxFileDataObject, 0 | 0 );
33138 if (!SWIG_IsOK(res1)) {
33139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33140 }
33141 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33142 {
33143 PyThreadState* __tstate = wxPyBeginAllowThreads();
33144 {
33145 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33146 result = (wxArrayString *) &_result_ref;
33147 }
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 {
33152 resultobj = wxArrayString2PyList_helper(*result);
33153 }
33154 return resultobj;
33155 fail:
33156 return NULL;
33157 }
33158
33159
33160 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33161 PyObject *resultobj = 0;
33162 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33163 wxString *arg2 = 0 ;
33164 void *argp1 = 0 ;
33165 int res1 = 0 ;
33166 bool temp2 = false ;
33167 PyObject * obj0 = 0 ;
33168 PyObject * obj1 = 0 ;
33169 char * kwnames[] = {
33170 (char *) "self",(char *) "filename", NULL
33171 };
33172
33173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33175 if (!SWIG_IsOK(res1)) {
33176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33177 }
33178 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33179 {
33180 arg2 = wxString_in_helper(obj1);
33181 if (arg2 == NULL) SWIG_fail;
33182 temp2 = true;
33183 }
33184 {
33185 PyThreadState* __tstate = wxPyBeginAllowThreads();
33186 (arg1)->AddFile((wxString const &)*arg2);
33187 wxPyEndAllowThreads(__tstate);
33188 if (PyErr_Occurred()) SWIG_fail;
33189 }
33190 resultobj = SWIG_Py_Void();
33191 {
33192 if (temp2)
33193 delete arg2;
33194 }
33195 return resultobj;
33196 fail:
33197 {
33198 if (temp2)
33199 delete arg2;
33200 }
33201 return NULL;
33202 }
33203
33204
33205 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33206 PyObject *obj;
33207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33208 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33209 return SWIG_Py_Void();
33210 }
33211
33212 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33213 return SWIG_Python_InitShadowInstance(args);
33214 }
33215
33216 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33217 PyObject *resultobj = 0;
33218 wxDataFormat *arg1 = 0 ;
33219 wxCustomDataObject *result = 0 ;
33220 void *argp1 = 0 ;
33221 int res1 = 0 ;
33222
33223 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33225 if (!SWIG_IsOK(res1)) {
33226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33227 }
33228 if (!argp1) {
33229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33230 }
33231 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33239 return resultobj;
33240 fail:
33241 return NULL;
33242 }
33243
33244
33245 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33246 PyObject *resultobj = 0;
33247 wxString *arg1 = 0 ;
33248 wxCustomDataObject *result = 0 ;
33249 bool temp1 = false ;
33250
33251 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33252 {
33253 arg1 = wxString_in_helper(swig_obj[0]);
33254 if (arg1 == NULL) SWIG_fail;
33255 temp1 = true;
33256 }
33257 {
33258 PyThreadState* __tstate = wxPyBeginAllowThreads();
33259 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33260 wxPyEndAllowThreads(__tstate);
33261 if (PyErr_Occurred()) SWIG_fail;
33262 }
33263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33264 {
33265 if (temp1)
33266 delete arg1;
33267 }
33268 return resultobj;
33269 fail:
33270 {
33271 if (temp1)
33272 delete arg1;
33273 }
33274 return NULL;
33275 }
33276
33277
33278 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33279 PyObject *resultobj = 0;
33280 wxCustomDataObject *result = 0 ;
33281
33282 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33283 {
33284 PyThreadState* __tstate = wxPyBeginAllowThreads();
33285 result = (wxCustomDataObject *)new wxCustomDataObject();
33286 wxPyEndAllowThreads(__tstate);
33287 if (PyErr_Occurred()) SWIG_fail;
33288 }
33289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33290 return resultobj;
33291 fail:
33292 return NULL;
33293 }
33294
33295
33296 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33297 int argc;
33298 PyObject *argv[2];
33299
33300 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33301 --argc;
33302 if (argc == 0) {
33303 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33304 }
33305 if (argc == 1) {
33306 int _v = 0;
33307 {
33308 {
33309 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33310 }
33311 }
33312 if (!_v) goto check_2;
33313 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33314 }
33315 check_2:
33316
33317 if (argc == 1) {
33318 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33319 }
33320
33321 fail:
33322 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33323 return NULL;
33324 }
33325
33326
33327 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33328 PyObject *resultobj = 0;
33329 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33330 PyObject *arg2 = (PyObject *) 0 ;
33331 bool result;
33332 void *argp1 = 0 ;
33333 int res1 = 0 ;
33334 PyObject * obj0 = 0 ;
33335 PyObject * obj1 = 0 ;
33336 char * kwnames[] = {
33337 (char *) "self",(char *) "data", NULL
33338 };
33339
33340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33342 if (!SWIG_IsOK(res1)) {
33343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33344 }
33345 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33346 arg2 = obj1;
33347 {
33348 PyThreadState* __tstate = wxPyBeginAllowThreads();
33349 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33350 wxPyEndAllowThreads(__tstate);
33351 if (PyErr_Occurred()) SWIG_fail;
33352 }
33353 {
33354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33355 }
33356 return resultobj;
33357 fail:
33358 return NULL;
33359 }
33360
33361
33362 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33363 PyObject *resultobj = 0;
33364 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33365 size_t result;
33366 void *argp1 = 0 ;
33367 int res1 = 0 ;
33368 PyObject *swig_obj[1] ;
33369
33370 if (!args) SWIG_fail;
33371 swig_obj[0] = args;
33372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33373 if (!SWIG_IsOK(res1)) {
33374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33375 }
33376 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33377 {
33378 PyThreadState* __tstate = wxPyBeginAllowThreads();
33379 result = (size_t)(arg1)->GetSize();
33380 wxPyEndAllowThreads(__tstate);
33381 if (PyErr_Occurred()) SWIG_fail;
33382 }
33383 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33384 return resultobj;
33385 fail:
33386 return NULL;
33387 }
33388
33389
33390 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33391 PyObject *resultobj = 0;
33392 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33393 PyObject *result = 0 ;
33394 void *argp1 = 0 ;
33395 int res1 = 0 ;
33396 PyObject *swig_obj[1] ;
33397
33398 if (!args) SWIG_fail;
33399 swig_obj[0] = args;
33400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33401 if (!SWIG_IsOK(res1)) {
33402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33403 }
33404 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33405 {
33406 PyThreadState* __tstate = wxPyBeginAllowThreads();
33407 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33408 wxPyEndAllowThreads(__tstate);
33409 if (PyErr_Occurred()) SWIG_fail;
33410 }
33411 resultobj = result;
33412 return resultobj;
33413 fail:
33414 return NULL;
33415 }
33416
33417
33418 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33419 PyObject *obj;
33420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33421 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33422 return SWIG_Py_Void();
33423 }
33424
33425 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33426 return SWIG_Python_InitShadowInstance(args);
33427 }
33428
33429 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33430 PyObject *resultobj = 0;
33431 wxString const &arg1_defvalue = wxPyEmptyString ;
33432 wxString *arg1 = (wxString *) &arg1_defvalue ;
33433 wxURLDataObject *result = 0 ;
33434 bool temp1 = false ;
33435 PyObject * obj0 = 0 ;
33436 char * kwnames[] = {
33437 (char *) "url", NULL
33438 };
33439
33440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33441 if (obj0) {
33442 {
33443 arg1 = wxString_in_helper(obj0);
33444 if (arg1 == NULL) SWIG_fail;
33445 temp1 = true;
33446 }
33447 }
33448 {
33449 PyThreadState* __tstate = wxPyBeginAllowThreads();
33450 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33451 wxPyEndAllowThreads(__tstate);
33452 if (PyErr_Occurred()) SWIG_fail;
33453 }
33454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33455 {
33456 if (temp1)
33457 delete arg1;
33458 }
33459 return resultobj;
33460 fail:
33461 {
33462 if (temp1)
33463 delete arg1;
33464 }
33465 return NULL;
33466 }
33467
33468
33469 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33470 PyObject *resultobj = 0;
33471 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33472 wxString result;
33473 void *argp1 = 0 ;
33474 int res1 = 0 ;
33475 PyObject *swig_obj[1] ;
33476
33477 if (!args) SWIG_fail;
33478 swig_obj[0] = args;
33479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33480 if (!SWIG_IsOK(res1)) {
33481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33482 }
33483 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = (arg1)->GetURL();
33487 wxPyEndAllowThreads(__tstate);
33488 if (PyErr_Occurred()) SWIG_fail;
33489 }
33490 {
33491 #if wxUSE_UNICODE
33492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33493 #else
33494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33495 #endif
33496 }
33497 return resultobj;
33498 fail:
33499 return NULL;
33500 }
33501
33502
33503 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33504 PyObject *resultobj = 0;
33505 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33506 wxString *arg2 = 0 ;
33507 void *argp1 = 0 ;
33508 int res1 = 0 ;
33509 bool temp2 = false ;
33510 PyObject * obj0 = 0 ;
33511 PyObject * obj1 = 0 ;
33512 char * kwnames[] = {
33513 (char *) "self",(char *) "url", NULL
33514 };
33515
33516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33518 if (!SWIG_IsOK(res1)) {
33519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33520 }
33521 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33522 {
33523 arg2 = wxString_in_helper(obj1);
33524 if (arg2 == NULL) SWIG_fail;
33525 temp2 = true;
33526 }
33527 {
33528 PyThreadState* __tstate = wxPyBeginAllowThreads();
33529 (arg1)->SetURL((wxString const &)*arg2);
33530 wxPyEndAllowThreads(__tstate);
33531 if (PyErr_Occurred()) SWIG_fail;
33532 }
33533 resultobj = SWIG_Py_Void();
33534 {
33535 if (temp2)
33536 delete arg2;
33537 }
33538 return resultobj;
33539 fail:
33540 {
33541 if (temp2)
33542 delete arg2;
33543 }
33544 return NULL;
33545 }
33546
33547
33548 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33549 PyObject *obj;
33550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33551 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33552 return SWIG_Py_Void();
33553 }
33554
33555 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33556 return SWIG_Python_InitShadowInstance(args);
33557 }
33558
33559 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33560 PyObject *resultobj = 0;
33561 wxMetafileDataObject *result = 0 ;
33562
33563 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33564 {
33565 PyThreadState* __tstate = wxPyBeginAllowThreads();
33566 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33571 return resultobj;
33572 fail:
33573 return NULL;
33574 }
33575
33576
33577 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33578 PyObject *obj;
33579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33580 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33581 return SWIG_Py_Void();
33582 }
33583
33584 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33585 return SWIG_Python_InitShadowInstance(args);
33586 }
33587
33588 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33589 PyObject *resultobj = 0;
33590 wxDragResult arg1 ;
33591 bool result;
33592 int val1 ;
33593 int ecode1 = 0 ;
33594 PyObject * obj0 = 0 ;
33595 char * kwnames[] = {
33596 (char *) "res", NULL
33597 };
33598
33599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33600 ecode1 = SWIG_AsVal_int(obj0, &val1);
33601 if (!SWIG_IsOK(ecode1)) {
33602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33603 }
33604 arg1 = static_cast< wxDragResult >(val1);
33605 {
33606 PyThreadState* __tstate = wxPyBeginAllowThreads();
33607 result = (bool)wxIsDragResultOk(arg1);
33608 wxPyEndAllowThreads(__tstate);
33609 if (PyErr_Occurred()) SWIG_fail;
33610 }
33611 {
33612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33613 }
33614 return resultobj;
33615 fail:
33616 return NULL;
33617 }
33618
33619
33620 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33621 PyObject *resultobj = 0;
33622 wxWindow *arg1 = (wxWindow *) 0 ;
33623 wxIcon const &arg2_defvalue = wxNullIcon ;
33624 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33625 wxIcon const &arg3_defvalue = wxNullIcon ;
33626 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33627 wxIcon const &arg4_defvalue = wxNullIcon ;
33628 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33629 wxPyDropSource *result = 0 ;
33630 void *argp1 = 0 ;
33631 int res1 = 0 ;
33632 void *argp2 = 0 ;
33633 int res2 = 0 ;
33634 void *argp3 = 0 ;
33635 int res3 = 0 ;
33636 void *argp4 = 0 ;
33637 int res4 = 0 ;
33638 PyObject * obj0 = 0 ;
33639 PyObject * obj1 = 0 ;
33640 PyObject * obj2 = 0 ;
33641 PyObject * obj3 = 0 ;
33642 char * kwnames[] = {
33643 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33644 };
33645
33646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33648 if (!SWIG_IsOK(res1)) {
33649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33650 }
33651 arg1 = reinterpret_cast< wxWindow * >(argp1);
33652 if (obj1) {
33653 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33654 if (!SWIG_IsOK(res2)) {
33655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33656 }
33657 if (!argp2) {
33658 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33659 }
33660 arg2 = reinterpret_cast< wxIcon * >(argp2);
33661 }
33662 if (obj2) {
33663 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33664 if (!SWIG_IsOK(res3)) {
33665 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33666 }
33667 if (!argp3) {
33668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33669 }
33670 arg3 = reinterpret_cast< wxIcon * >(argp3);
33671 }
33672 if (obj3) {
33673 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33674 if (!SWIG_IsOK(res4)) {
33675 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33676 }
33677 if (!argp4) {
33678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33679 }
33680 arg4 = reinterpret_cast< wxIcon * >(argp4);
33681 }
33682 {
33683 PyThreadState* __tstate = wxPyBeginAllowThreads();
33684 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33685 wxPyEndAllowThreads(__tstate);
33686 if (PyErr_Occurred()) SWIG_fail;
33687 }
33688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33689 return resultobj;
33690 fail:
33691 return NULL;
33692 }
33693
33694
33695 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33696 PyObject *resultobj = 0;
33697 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33698 PyObject *arg2 = (PyObject *) 0 ;
33699 PyObject *arg3 = (PyObject *) 0 ;
33700 int arg4 ;
33701 void *argp1 = 0 ;
33702 int res1 = 0 ;
33703 int val4 ;
33704 int ecode4 = 0 ;
33705 PyObject * obj0 = 0 ;
33706 PyObject * obj1 = 0 ;
33707 PyObject * obj2 = 0 ;
33708 PyObject * obj3 = 0 ;
33709 char * kwnames[] = {
33710 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33711 };
33712
33713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33715 if (!SWIG_IsOK(res1)) {
33716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33717 }
33718 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33719 arg2 = obj1;
33720 arg3 = obj2;
33721 ecode4 = SWIG_AsVal_int(obj3, &val4);
33722 if (!SWIG_IsOK(ecode4)) {
33723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33724 }
33725 arg4 = static_cast< int >(val4);
33726 {
33727 PyThreadState* __tstate = wxPyBeginAllowThreads();
33728 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33729 wxPyEndAllowThreads(__tstate);
33730 if (PyErr_Occurred()) SWIG_fail;
33731 }
33732 resultobj = SWIG_Py_Void();
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33740 PyObject *resultobj = 0;
33741 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33742 void *argp1 = 0 ;
33743 int res1 = 0 ;
33744 PyObject *swig_obj[1] ;
33745
33746 if (!args) SWIG_fail;
33747 swig_obj[0] = args;
33748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33749 if (!SWIG_IsOK(res1)) {
33750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33751 }
33752 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33753 {
33754 PyThreadState* __tstate = wxPyBeginAllowThreads();
33755 delete arg1;
33756
33757 wxPyEndAllowThreads(__tstate);
33758 if (PyErr_Occurred()) SWIG_fail;
33759 }
33760 resultobj = SWIG_Py_Void();
33761 return resultobj;
33762 fail:
33763 return NULL;
33764 }
33765
33766
33767 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33768 PyObject *resultobj = 0;
33769 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33770 wxDataObject *arg2 = 0 ;
33771 void *argp1 = 0 ;
33772 int res1 = 0 ;
33773 void *argp2 = 0 ;
33774 int res2 = 0 ;
33775 PyObject * obj0 = 0 ;
33776 PyObject * obj1 = 0 ;
33777 char * kwnames[] = {
33778 (char *) "self",(char *) "data", NULL
33779 };
33780
33781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33783 if (!SWIG_IsOK(res1)) {
33784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33785 }
33786 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33787 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33788 if (!SWIG_IsOK(res2)) {
33789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33790 }
33791 if (!argp2) {
33792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33793 }
33794 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33795 {
33796 PyThreadState* __tstate = wxPyBeginAllowThreads();
33797 (arg1)->SetData(*arg2);
33798 wxPyEndAllowThreads(__tstate);
33799 if (PyErr_Occurred()) SWIG_fail;
33800 }
33801 resultobj = SWIG_Py_Void();
33802 return resultobj;
33803 fail:
33804 return NULL;
33805 }
33806
33807
33808 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33809 PyObject *resultobj = 0;
33810 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33811 wxDataObject *result = 0 ;
33812 void *argp1 = 0 ;
33813 int res1 = 0 ;
33814 PyObject *swig_obj[1] ;
33815
33816 if (!args) SWIG_fail;
33817 swig_obj[0] = args;
33818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33819 if (!SWIG_IsOK(res1)) {
33820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33821 }
33822 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33823 {
33824 PyThreadState* __tstate = wxPyBeginAllowThreads();
33825 result = (wxDataObject *)(arg1)->GetDataObject();
33826 wxPyEndAllowThreads(__tstate);
33827 if (PyErr_Occurred()) SWIG_fail;
33828 }
33829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33830 return resultobj;
33831 fail:
33832 return NULL;
33833 }
33834
33835
33836 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33837 PyObject *resultobj = 0;
33838 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33839 wxDragResult arg2 ;
33840 wxCursor *arg3 = 0 ;
33841 void *argp1 = 0 ;
33842 int res1 = 0 ;
33843 int val2 ;
33844 int ecode2 = 0 ;
33845 void *argp3 = 0 ;
33846 int res3 = 0 ;
33847 PyObject * obj0 = 0 ;
33848 PyObject * obj1 = 0 ;
33849 PyObject * obj2 = 0 ;
33850 char * kwnames[] = {
33851 (char *) "self",(char *) "res",(char *) "cursor", NULL
33852 };
33853
33854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33856 if (!SWIG_IsOK(res1)) {
33857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33858 }
33859 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33860 ecode2 = SWIG_AsVal_int(obj1, &val2);
33861 if (!SWIG_IsOK(ecode2)) {
33862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33863 }
33864 arg2 = static_cast< wxDragResult >(val2);
33865 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33866 if (!SWIG_IsOK(res3)) {
33867 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33868 }
33869 if (!argp3) {
33870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33871 }
33872 arg3 = reinterpret_cast< wxCursor * >(argp3);
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33876 wxPyEndAllowThreads(__tstate);
33877 if (PyErr_Occurred()) SWIG_fail;
33878 }
33879 resultobj = SWIG_Py_Void();
33880 return resultobj;
33881 fail:
33882 return NULL;
33883 }
33884
33885
33886 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33887 PyObject *resultobj = 0;
33888 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33889 int arg2 = (int) wxDrag_CopyOnly ;
33890 wxDragResult result;
33891 void *argp1 = 0 ;
33892 int res1 = 0 ;
33893 int val2 ;
33894 int ecode2 = 0 ;
33895 PyObject * obj0 = 0 ;
33896 PyObject * obj1 = 0 ;
33897 char * kwnames[] = {
33898 (char *) "self",(char *) "flags", NULL
33899 };
33900
33901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33903 if (!SWIG_IsOK(res1)) {
33904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33905 }
33906 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33907 if (obj1) {
33908 ecode2 = SWIG_AsVal_int(obj1, &val2);
33909 if (!SWIG_IsOK(ecode2)) {
33910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33911 }
33912 arg2 = static_cast< int >(val2);
33913 }
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 resultobj = SWIG_From_int(static_cast< int >(result));
33921 return resultobj;
33922 fail:
33923 return NULL;
33924 }
33925
33926
33927 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33928 PyObject *resultobj = 0;
33929 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33930 wxDragResult arg2 ;
33931 bool result;
33932 void *argp1 = 0 ;
33933 int res1 = 0 ;
33934 int val2 ;
33935 int ecode2 = 0 ;
33936 PyObject * obj0 = 0 ;
33937 PyObject * obj1 = 0 ;
33938 char * kwnames[] = {
33939 (char *) "self",(char *) "effect", NULL
33940 };
33941
33942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
33943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33944 if (!SWIG_IsOK(res1)) {
33945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33946 }
33947 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33948 ecode2 = SWIG_AsVal_int(obj1, &val2);
33949 if (!SWIG_IsOK(ecode2)) {
33950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
33951 }
33952 arg2 = static_cast< wxDragResult >(val2);
33953 {
33954 PyThreadState* __tstate = wxPyBeginAllowThreads();
33955 result = (bool)(arg1)->GiveFeedback(arg2);
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 {
33960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33961 }
33962 return resultobj;
33963 fail:
33964 return NULL;
33965 }
33966
33967
33968 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33969 PyObject *obj;
33970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33971 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
33972 return SWIG_Py_Void();
33973 }
33974
33975 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33976 return SWIG_Python_InitShadowInstance(args);
33977 }
33978
33979 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33980 PyObject *resultobj = 0;
33981 wxDataObject *arg1 = (wxDataObject *) NULL ;
33982 wxPyDropTarget *result = 0 ;
33983 int res1 = 0 ;
33984 PyObject * obj0 = 0 ;
33985 char * kwnames[] = {
33986 (char *) "dataObject", NULL
33987 };
33988
33989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
33990 if (obj0) {
33991 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33992 if (!SWIG_IsOK(res1)) {
33993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
33994 }
33995 }
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = 0;
34011 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34012 PyObject *arg2 = (PyObject *) 0 ;
34013 PyObject *arg3 = (PyObject *) 0 ;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 PyObject * obj0 = 0 ;
34017 PyObject * obj1 = 0 ;
34018 PyObject * obj2 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "self",(char *) "self",(char *) "_class", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34025 if (!SWIG_IsOK(res1)) {
34026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34027 }
34028 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34029 arg2 = obj1;
34030 arg3 = obj2;
34031 {
34032 PyThreadState* __tstate = wxPyBeginAllowThreads();
34033 (arg1)->_setCallbackInfo(arg2,arg3);
34034 wxPyEndAllowThreads(__tstate);
34035 if (PyErr_Occurred()) SWIG_fail;
34036 }
34037 resultobj = SWIG_Py_Void();
34038 return resultobj;
34039 fail:
34040 return NULL;
34041 }
34042
34043
34044 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34045 PyObject *resultobj = 0;
34046 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34047 void *argp1 = 0 ;
34048 int res1 = 0 ;
34049 PyObject *swig_obj[1] ;
34050
34051 if (!args) SWIG_fail;
34052 swig_obj[0] = args;
34053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34054 if (!SWIG_IsOK(res1)) {
34055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34056 }
34057 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34058 {
34059 PyThreadState* __tstate = wxPyBeginAllowThreads();
34060 delete arg1;
34061
34062 wxPyEndAllowThreads(__tstate);
34063 if (PyErr_Occurred()) SWIG_fail;
34064 }
34065 resultobj = SWIG_Py_Void();
34066 return resultobj;
34067 fail:
34068 return NULL;
34069 }
34070
34071
34072 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34073 PyObject *resultobj = 0;
34074 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34075 wxDataObject *result = 0 ;
34076 void *argp1 = 0 ;
34077 int res1 = 0 ;
34078 PyObject *swig_obj[1] ;
34079
34080 if (!args) SWIG_fail;
34081 swig_obj[0] = args;
34082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34083 if (!SWIG_IsOK(res1)) {
34084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34085 }
34086 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34087 {
34088 PyThreadState* __tstate = wxPyBeginAllowThreads();
34089 result = (wxDataObject *)(arg1)->GetDataObject();
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34094 return resultobj;
34095 fail:
34096 return NULL;
34097 }
34098
34099
34100 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34101 PyObject *resultobj = 0;
34102 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34103 wxDataObject *arg2 = (wxDataObject *) 0 ;
34104 void *argp1 = 0 ;
34105 int res1 = 0 ;
34106 int res2 = 0 ;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 char * kwnames[] = {
34110 (char *) "self",(char *) "dataObject", NULL
34111 };
34112
34113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34115 if (!SWIG_IsOK(res1)) {
34116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34117 }
34118 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34119 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34120 if (!SWIG_IsOK(res2)) {
34121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34122 }
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 (arg1)->SetDataObject(arg2);
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 resultobj = SWIG_Py_Void();
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34137 PyObject *resultobj = 0;
34138 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34139 int arg2 ;
34140 int arg3 ;
34141 wxDragResult arg4 ;
34142 wxDragResult result;
34143 void *argp1 = 0 ;
34144 int res1 = 0 ;
34145 int val2 ;
34146 int ecode2 = 0 ;
34147 int val3 ;
34148 int ecode3 = 0 ;
34149 int val4 ;
34150 int ecode4 = 0 ;
34151 PyObject * obj0 = 0 ;
34152 PyObject * obj1 = 0 ;
34153 PyObject * obj2 = 0 ;
34154 PyObject * obj3 = 0 ;
34155 char * kwnames[] = {
34156 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34157 };
34158
34159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34161 if (!SWIG_IsOK(res1)) {
34162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34163 }
34164 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34165 ecode2 = SWIG_AsVal_int(obj1, &val2);
34166 if (!SWIG_IsOK(ecode2)) {
34167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34168 }
34169 arg2 = static_cast< int >(val2);
34170 ecode3 = SWIG_AsVal_int(obj2, &val3);
34171 if (!SWIG_IsOK(ecode3)) {
34172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34173 }
34174 arg3 = static_cast< int >(val3);
34175 ecode4 = SWIG_AsVal_int(obj3, &val4);
34176 if (!SWIG_IsOK(ecode4)) {
34177 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34178 }
34179 arg4 = static_cast< wxDragResult >(val4);
34180 {
34181 PyThreadState* __tstate = wxPyBeginAllowThreads();
34182 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34183 wxPyEndAllowThreads(__tstate);
34184 if (PyErr_Occurred()) SWIG_fail;
34185 }
34186 resultobj = SWIG_From_int(static_cast< int >(result));
34187 return resultobj;
34188 fail:
34189 return NULL;
34190 }
34191
34192
34193 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34194 PyObject *resultobj = 0;
34195 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34196 int arg2 ;
34197 int arg3 ;
34198 wxDragResult arg4 ;
34199 wxDragResult result;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 int val2 ;
34203 int ecode2 = 0 ;
34204 int val3 ;
34205 int ecode3 = 0 ;
34206 int val4 ;
34207 int ecode4 = 0 ;
34208 PyObject * obj0 = 0 ;
34209 PyObject * obj1 = 0 ;
34210 PyObject * obj2 = 0 ;
34211 PyObject * obj3 = 0 ;
34212 char * kwnames[] = {
34213 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34214 };
34215
34216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34220 }
34221 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34222 ecode2 = SWIG_AsVal_int(obj1, &val2);
34223 if (!SWIG_IsOK(ecode2)) {
34224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34225 }
34226 arg2 = static_cast< int >(val2);
34227 ecode3 = SWIG_AsVal_int(obj2, &val3);
34228 if (!SWIG_IsOK(ecode3)) {
34229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34230 }
34231 arg3 = static_cast< int >(val3);
34232 ecode4 = SWIG_AsVal_int(obj3, &val4);
34233 if (!SWIG_IsOK(ecode4)) {
34234 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34235 }
34236 arg4 = static_cast< wxDragResult >(val4);
34237 {
34238 PyThreadState* __tstate = wxPyBeginAllowThreads();
34239 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34240 wxPyEndAllowThreads(__tstate);
34241 if (PyErr_Occurred()) SWIG_fail;
34242 }
34243 resultobj = SWIG_From_int(static_cast< int >(result));
34244 return resultobj;
34245 fail:
34246 return NULL;
34247 }
34248
34249
34250 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34251 PyObject *resultobj = 0;
34252 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34253 void *argp1 = 0 ;
34254 int res1 = 0 ;
34255 PyObject *swig_obj[1] ;
34256
34257 if (!args) SWIG_fail;
34258 swig_obj[0] = args;
34259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34260 if (!SWIG_IsOK(res1)) {
34261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34262 }
34263 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 (arg1)->OnLeave();
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 resultobj = SWIG_Py_Void();
34271 return resultobj;
34272 fail:
34273 return NULL;
34274 }
34275
34276
34277 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34278 PyObject *resultobj = 0;
34279 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34280 int arg2 ;
34281 int arg3 ;
34282 bool result;
34283 void *argp1 = 0 ;
34284 int res1 = 0 ;
34285 int val2 ;
34286 int ecode2 = 0 ;
34287 int val3 ;
34288 int ecode3 = 0 ;
34289 PyObject * obj0 = 0 ;
34290 PyObject * obj1 = 0 ;
34291 PyObject * obj2 = 0 ;
34292 char * kwnames[] = {
34293 (char *) "self",(char *) "x",(char *) "y", NULL
34294 };
34295
34296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34298 if (!SWIG_IsOK(res1)) {
34299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34300 }
34301 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34302 ecode2 = SWIG_AsVal_int(obj1, &val2);
34303 if (!SWIG_IsOK(ecode2)) {
34304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34305 }
34306 arg2 = static_cast< int >(val2);
34307 ecode3 = SWIG_AsVal_int(obj2, &val3);
34308 if (!SWIG_IsOK(ecode3)) {
34309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34310 }
34311 arg3 = static_cast< int >(val3);
34312 {
34313 PyThreadState* __tstate = wxPyBeginAllowThreads();
34314 result = (bool)(arg1)->OnDrop(arg2,arg3);
34315 wxPyEndAllowThreads(__tstate);
34316 if (PyErr_Occurred()) SWIG_fail;
34317 }
34318 {
34319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34320 }
34321 return resultobj;
34322 fail:
34323 return NULL;
34324 }
34325
34326
34327 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34328 PyObject *resultobj = 0;
34329 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34330 bool result;
34331 void *argp1 = 0 ;
34332 int res1 = 0 ;
34333 PyObject *swig_obj[1] ;
34334
34335 if (!args) SWIG_fail;
34336 swig_obj[0] = args;
34337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34338 if (!SWIG_IsOK(res1)) {
34339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34340 }
34341 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 result = (bool)(arg1)->GetData();
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 {
34349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34350 }
34351 return resultobj;
34352 fail:
34353 return NULL;
34354 }
34355
34356
34357 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34358 PyObject *resultobj = 0;
34359 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34360 wxDragResult arg2 ;
34361 void *argp1 = 0 ;
34362 int res1 = 0 ;
34363 int val2 ;
34364 int ecode2 = 0 ;
34365 PyObject * obj0 = 0 ;
34366 PyObject * obj1 = 0 ;
34367 char * kwnames[] = {
34368 (char *) "self",(char *) "action", NULL
34369 };
34370
34371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34373 if (!SWIG_IsOK(res1)) {
34374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34375 }
34376 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34377 ecode2 = SWIG_AsVal_int(obj1, &val2);
34378 if (!SWIG_IsOK(ecode2)) {
34379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34380 }
34381 arg2 = static_cast< wxDragResult >(val2);
34382 {
34383 PyThreadState* __tstate = wxPyBeginAllowThreads();
34384 (arg1)->SetDefaultAction(arg2);
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 resultobj = SWIG_Py_Void();
34389 return resultobj;
34390 fail:
34391 return NULL;
34392 }
34393
34394
34395 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34396 PyObject *resultobj = 0;
34397 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34398 wxDragResult result;
34399 void *argp1 = 0 ;
34400 int res1 = 0 ;
34401 PyObject *swig_obj[1] ;
34402
34403 if (!args) SWIG_fail;
34404 swig_obj[0] = args;
34405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34406 if (!SWIG_IsOK(res1)) {
34407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34408 }
34409 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34410 {
34411 PyThreadState* __tstate = wxPyBeginAllowThreads();
34412 result = (wxDragResult)(arg1)->GetDefaultAction();
34413 wxPyEndAllowThreads(__tstate);
34414 if (PyErr_Occurred()) SWIG_fail;
34415 }
34416 resultobj = SWIG_From_int(static_cast< int >(result));
34417 return resultobj;
34418 fail:
34419 return NULL;
34420 }
34421
34422
34423 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34424 PyObject *obj;
34425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34426 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34427 return SWIG_Py_Void();
34428 }
34429
34430 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34431 return SWIG_Python_InitShadowInstance(args);
34432 }
34433
34434 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34435 PyObject *resultobj = 0;
34436 wxPyTextDropTarget *result = 0 ;
34437
34438 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34439 {
34440 PyThreadState* __tstate = wxPyBeginAllowThreads();
34441 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34446 return resultobj;
34447 fail:
34448 return NULL;
34449 }
34450
34451
34452 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34453 PyObject *resultobj = 0;
34454 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34455 PyObject *arg2 = (PyObject *) 0 ;
34456 PyObject *arg3 = (PyObject *) 0 ;
34457 void *argp1 = 0 ;
34458 int res1 = 0 ;
34459 PyObject * obj0 = 0 ;
34460 PyObject * obj1 = 0 ;
34461 PyObject * obj2 = 0 ;
34462 char * kwnames[] = {
34463 (char *) "self",(char *) "self",(char *) "_class", NULL
34464 };
34465
34466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34468 if (!SWIG_IsOK(res1)) {
34469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34470 }
34471 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34472 arg2 = obj1;
34473 arg3 = obj2;
34474 {
34475 PyThreadState* __tstate = wxPyBeginAllowThreads();
34476 (arg1)->_setCallbackInfo(arg2,arg3);
34477 wxPyEndAllowThreads(__tstate);
34478 if (PyErr_Occurred()) SWIG_fail;
34479 }
34480 resultobj = SWIG_Py_Void();
34481 return resultobj;
34482 fail:
34483 return NULL;
34484 }
34485
34486
34487 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34488 PyObject *resultobj = 0;
34489 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34490 int arg2 ;
34491 int arg3 ;
34492 wxString *arg4 = 0 ;
34493 bool result;
34494 void *argp1 = 0 ;
34495 int res1 = 0 ;
34496 int val2 ;
34497 int ecode2 = 0 ;
34498 int val3 ;
34499 int ecode3 = 0 ;
34500 bool temp4 = false ;
34501 PyObject * obj0 = 0 ;
34502 PyObject * obj1 = 0 ;
34503 PyObject * obj2 = 0 ;
34504 PyObject * obj3 = 0 ;
34505 char * kwnames[] = {
34506 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34507 };
34508
34509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34511 if (!SWIG_IsOK(res1)) {
34512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34513 }
34514 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34515 ecode2 = SWIG_AsVal_int(obj1, &val2);
34516 if (!SWIG_IsOK(ecode2)) {
34517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34518 }
34519 arg2 = static_cast< int >(val2);
34520 ecode3 = SWIG_AsVal_int(obj2, &val3);
34521 if (!SWIG_IsOK(ecode3)) {
34522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34523 }
34524 arg3 = static_cast< int >(val3);
34525 {
34526 arg4 = wxString_in_helper(obj3);
34527 if (arg4 == NULL) SWIG_fail;
34528 temp4 = true;
34529 }
34530 {
34531 PyThreadState* __tstate = wxPyBeginAllowThreads();
34532 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34533 wxPyEndAllowThreads(__tstate);
34534 if (PyErr_Occurred()) SWIG_fail;
34535 }
34536 {
34537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34538 }
34539 {
34540 if (temp4)
34541 delete arg4;
34542 }
34543 return resultobj;
34544 fail:
34545 {
34546 if (temp4)
34547 delete arg4;
34548 }
34549 return NULL;
34550 }
34551
34552
34553 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34554 PyObject *resultobj = 0;
34555 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34556 int arg2 ;
34557 int arg3 ;
34558 wxDragResult arg4 ;
34559 wxDragResult result;
34560 void *argp1 = 0 ;
34561 int res1 = 0 ;
34562 int val2 ;
34563 int ecode2 = 0 ;
34564 int val3 ;
34565 int ecode3 = 0 ;
34566 int val4 ;
34567 int ecode4 = 0 ;
34568 PyObject * obj0 = 0 ;
34569 PyObject * obj1 = 0 ;
34570 PyObject * obj2 = 0 ;
34571 PyObject * obj3 = 0 ;
34572 char * kwnames[] = {
34573 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34574 };
34575
34576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34578 if (!SWIG_IsOK(res1)) {
34579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34580 }
34581 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34582 ecode2 = SWIG_AsVal_int(obj1, &val2);
34583 if (!SWIG_IsOK(ecode2)) {
34584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34585 }
34586 arg2 = static_cast< int >(val2);
34587 ecode3 = SWIG_AsVal_int(obj2, &val3);
34588 if (!SWIG_IsOK(ecode3)) {
34589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34590 }
34591 arg3 = static_cast< int >(val3);
34592 ecode4 = SWIG_AsVal_int(obj3, &val4);
34593 if (!SWIG_IsOK(ecode4)) {
34594 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34595 }
34596 arg4 = static_cast< wxDragResult >(val4);
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_From_int(static_cast< int >(result));
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34611 PyObject *resultobj = 0;
34612 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34613 int arg2 ;
34614 int arg3 ;
34615 wxDragResult arg4 ;
34616 wxDragResult result;
34617 void *argp1 = 0 ;
34618 int res1 = 0 ;
34619 int val2 ;
34620 int ecode2 = 0 ;
34621 int val3 ;
34622 int ecode3 = 0 ;
34623 int val4 ;
34624 int ecode4 = 0 ;
34625 PyObject * obj0 = 0 ;
34626 PyObject * obj1 = 0 ;
34627 PyObject * obj2 = 0 ;
34628 PyObject * obj3 = 0 ;
34629 char * kwnames[] = {
34630 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34631 };
34632
34633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34635 if (!SWIG_IsOK(res1)) {
34636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34637 }
34638 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34639 ecode2 = SWIG_AsVal_int(obj1, &val2);
34640 if (!SWIG_IsOK(ecode2)) {
34641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34642 }
34643 arg2 = static_cast< int >(val2);
34644 ecode3 = SWIG_AsVal_int(obj2, &val3);
34645 if (!SWIG_IsOK(ecode3)) {
34646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34647 }
34648 arg3 = static_cast< int >(val3);
34649 ecode4 = SWIG_AsVal_int(obj3, &val4);
34650 if (!SWIG_IsOK(ecode4)) {
34651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34652 }
34653 arg4 = static_cast< wxDragResult >(val4);
34654 {
34655 PyThreadState* __tstate = wxPyBeginAllowThreads();
34656 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34657 wxPyEndAllowThreads(__tstate);
34658 if (PyErr_Occurred()) SWIG_fail;
34659 }
34660 resultobj = SWIG_From_int(static_cast< int >(result));
34661 return resultobj;
34662 fail:
34663 return NULL;
34664 }
34665
34666
34667 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34668 PyObject *resultobj = 0;
34669 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34670 void *argp1 = 0 ;
34671 int res1 = 0 ;
34672 PyObject *swig_obj[1] ;
34673
34674 if (!args) SWIG_fail;
34675 swig_obj[0] = args;
34676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34677 if (!SWIG_IsOK(res1)) {
34678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34679 }
34680 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 (arg1)->OnLeave();
34684 wxPyEndAllowThreads(__tstate);
34685 if (PyErr_Occurred()) SWIG_fail;
34686 }
34687 resultobj = SWIG_Py_Void();
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj = 0;
34696 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34697 int arg2 ;
34698 int arg3 ;
34699 bool result;
34700 void *argp1 = 0 ;
34701 int res1 = 0 ;
34702 int val2 ;
34703 int ecode2 = 0 ;
34704 int val3 ;
34705 int ecode3 = 0 ;
34706 PyObject * obj0 = 0 ;
34707 PyObject * obj1 = 0 ;
34708 PyObject * obj2 = 0 ;
34709 char * kwnames[] = {
34710 (char *) "self",(char *) "x",(char *) "y", NULL
34711 };
34712
34713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34715 if (!SWIG_IsOK(res1)) {
34716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34717 }
34718 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34719 ecode2 = SWIG_AsVal_int(obj1, &val2);
34720 if (!SWIG_IsOK(ecode2)) {
34721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34722 }
34723 arg2 = static_cast< int >(val2);
34724 ecode3 = SWIG_AsVal_int(obj2, &val3);
34725 if (!SWIG_IsOK(ecode3)) {
34726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34727 }
34728 arg3 = static_cast< int >(val3);
34729 {
34730 PyThreadState* __tstate = wxPyBeginAllowThreads();
34731 result = (bool)(arg1)->OnDrop(arg2,arg3);
34732 wxPyEndAllowThreads(__tstate);
34733 if (PyErr_Occurred()) SWIG_fail;
34734 }
34735 {
34736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34737 }
34738 return resultobj;
34739 fail:
34740 return NULL;
34741 }
34742
34743
34744 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34745 PyObject *resultobj = 0;
34746 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34747 int arg2 ;
34748 int arg3 ;
34749 wxDragResult arg4 ;
34750 wxDragResult result;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 int val2 ;
34754 int ecode2 = 0 ;
34755 int val3 ;
34756 int ecode3 = 0 ;
34757 int val4 ;
34758 int ecode4 = 0 ;
34759 PyObject * obj0 = 0 ;
34760 PyObject * obj1 = 0 ;
34761 PyObject * obj2 = 0 ;
34762 PyObject * obj3 = 0 ;
34763 char * kwnames[] = {
34764 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34765 };
34766
34767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34769 if (!SWIG_IsOK(res1)) {
34770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34771 }
34772 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34773 ecode2 = SWIG_AsVal_int(obj1, &val2);
34774 if (!SWIG_IsOK(ecode2)) {
34775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34776 }
34777 arg2 = static_cast< int >(val2);
34778 ecode3 = SWIG_AsVal_int(obj2, &val3);
34779 if (!SWIG_IsOK(ecode3)) {
34780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34781 }
34782 arg3 = static_cast< int >(val3);
34783 ecode4 = SWIG_AsVal_int(obj3, &val4);
34784 if (!SWIG_IsOK(ecode4)) {
34785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34786 }
34787 arg4 = static_cast< wxDragResult >(val4);
34788 {
34789 PyThreadState* __tstate = wxPyBeginAllowThreads();
34790 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34791 wxPyEndAllowThreads(__tstate);
34792 if (PyErr_Occurred()) SWIG_fail;
34793 }
34794 resultobj = SWIG_From_int(static_cast< int >(result));
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34802 PyObject *obj;
34803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34804 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34805 return SWIG_Py_Void();
34806 }
34807
34808 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34809 return SWIG_Python_InitShadowInstance(args);
34810 }
34811
34812 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34813 PyObject *resultobj = 0;
34814 wxPyFileDropTarget *result = 0 ;
34815
34816 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34817 {
34818 PyThreadState* __tstate = wxPyBeginAllowThreads();
34819 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34820 wxPyEndAllowThreads(__tstate);
34821 if (PyErr_Occurred()) SWIG_fail;
34822 }
34823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34824 return resultobj;
34825 fail:
34826 return NULL;
34827 }
34828
34829
34830 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34831 PyObject *resultobj = 0;
34832 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34833 PyObject *arg2 = (PyObject *) 0 ;
34834 PyObject *arg3 = (PyObject *) 0 ;
34835 void *argp1 = 0 ;
34836 int res1 = 0 ;
34837 PyObject * obj0 = 0 ;
34838 PyObject * obj1 = 0 ;
34839 PyObject * obj2 = 0 ;
34840 char * kwnames[] = {
34841 (char *) "self",(char *) "self",(char *) "_class", NULL
34842 };
34843
34844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34846 if (!SWIG_IsOK(res1)) {
34847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34848 }
34849 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34850 arg2 = obj1;
34851 arg3 = obj2;
34852 {
34853 PyThreadState* __tstate = wxPyBeginAllowThreads();
34854 (arg1)->_setCallbackInfo(arg2,arg3);
34855 wxPyEndAllowThreads(__tstate);
34856 if (PyErr_Occurred()) SWIG_fail;
34857 }
34858 resultobj = SWIG_Py_Void();
34859 return resultobj;
34860 fail:
34861 return NULL;
34862 }
34863
34864
34865 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34866 PyObject *resultobj = 0;
34867 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34868 int arg2 ;
34869 int arg3 ;
34870 wxArrayString *arg4 = 0 ;
34871 bool result;
34872 void *argp1 = 0 ;
34873 int res1 = 0 ;
34874 int val2 ;
34875 int ecode2 = 0 ;
34876 int val3 ;
34877 int ecode3 = 0 ;
34878 bool temp4 = false ;
34879 PyObject * obj0 = 0 ;
34880 PyObject * obj1 = 0 ;
34881 PyObject * obj2 = 0 ;
34882 PyObject * obj3 = 0 ;
34883 char * kwnames[] = {
34884 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34885 };
34886
34887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34889 if (!SWIG_IsOK(res1)) {
34890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34891 }
34892 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34893 ecode2 = SWIG_AsVal_int(obj1, &val2);
34894 if (!SWIG_IsOK(ecode2)) {
34895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34896 }
34897 arg2 = static_cast< int >(val2);
34898 ecode3 = SWIG_AsVal_int(obj2, &val3);
34899 if (!SWIG_IsOK(ecode3)) {
34900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34901 }
34902 arg3 = static_cast< int >(val3);
34903 {
34904 if (! PySequence_Check(obj3)) {
34905 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34906 SWIG_fail;
34907 }
34908 arg4 = new wxArrayString;
34909 temp4 = true;
34910 int i, len=PySequence_Length(obj3);
34911 for (i=0; i<len; i++) {
34912 PyObject* item = PySequence_GetItem(obj3, i);
34913 wxString* s = wxString_in_helper(item);
34914 if (PyErr_Occurred()) SWIG_fail;
34915 arg4->Add(*s);
34916 delete s;
34917 Py_DECREF(item);
34918 }
34919 }
34920 {
34921 PyThreadState* __tstate = wxPyBeginAllowThreads();
34922 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34923 wxPyEndAllowThreads(__tstate);
34924 if (PyErr_Occurred()) SWIG_fail;
34925 }
34926 {
34927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34928 }
34929 {
34930 if (temp4) delete arg4;
34931 }
34932 return resultobj;
34933 fail:
34934 {
34935 if (temp4) delete arg4;
34936 }
34937 return NULL;
34938 }
34939
34940
34941 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34942 PyObject *resultobj = 0;
34943 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34944 int arg2 ;
34945 int arg3 ;
34946 wxDragResult arg4 ;
34947 wxDragResult result;
34948 void *argp1 = 0 ;
34949 int res1 = 0 ;
34950 int val2 ;
34951 int ecode2 = 0 ;
34952 int val3 ;
34953 int ecode3 = 0 ;
34954 int val4 ;
34955 int ecode4 = 0 ;
34956 PyObject * obj0 = 0 ;
34957 PyObject * obj1 = 0 ;
34958 PyObject * obj2 = 0 ;
34959 PyObject * obj3 = 0 ;
34960 char * kwnames[] = {
34961 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34962 };
34963
34964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34966 if (!SWIG_IsOK(res1)) {
34967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34968 }
34969 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34970 ecode2 = SWIG_AsVal_int(obj1, &val2);
34971 if (!SWIG_IsOK(ecode2)) {
34972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34973 }
34974 arg2 = static_cast< int >(val2);
34975 ecode3 = SWIG_AsVal_int(obj2, &val3);
34976 if (!SWIG_IsOK(ecode3)) {
34977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34978 }
34979 arg3 = static_cast< int >(val3);
34980 ecode4 = SWIG_AsVal_int(obj3, &val4);
34981 if (!SWIG_IsOK(ecode4)) {
34982 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34983 }
34984 arg4 = static_cast< wxDragResult >(val4);
34985 {
34986 PyThreadState* __tstate = wxPyBeginAllowThreads();
34987 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34988 wxPyEndAllowThreads(__tstate);
34989 if (PyErr_Occurred()) SWIG_fail;
34990 }
34991 resultobj = SWIG_From_int(static_cast< int >(result));
34992 return resultobj;
34993 fail:
34994 return NULL;
34995 }
34996
34997
34998 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34999 PyObject *resultobj = 0;
35000 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35001 int arg2 ;
35002 int arg3 ;
35003 wxDragResult arg4 ;
35004 wxDragResult result;
35005 void *argp1 = 0 ;
35006 int res1 = 0 ;
35007 int val2 ;
35008 int ecode2 = 0 ;
35009 int val3 ;
35010 int ecode3 = 0 ;
35011 int val4 ;
35012 int ecode4 = 0 ;
35013 PyObject * obj0 = 0 ;
35014 PyObject * obj1 = 0 ;
35015 PyObject * obj2 = 0 ;
35016 PyObject * obj3 = 0 ;
35017 char * kwnames[] = {
35018 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35019 };
35020
35021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35023 if (!SWIG_IsOK(res1)) {
35024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35025 }
35026 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35027 ecode2 = SWIG_AsVal_int(obj1, &val2);
35028 if (!SWIG_IsOK(ecode2)) {
35029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35030 }
35031 arg2 = static_cast< int >(val2);
35032 ecode3 = SWIG_AsVal_int(obj2, &val3);
35033 if (!SWIG_IsOK(ecode3)) {
35034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35035 }
35036 arg3 = static_cast< int >(val3);
35037 ecode4 = SWIG_AsVal_int(obj3, &val4);
35038 if (!SWIG_IsOK(ecode4)) {
35039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35040 }
35041 arg4 = static_cast< wxDragResult >(val4);
35042 {
35043 PyThreadState* __tstate = wxPyBeginAllowThreads();
35044 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35045 wxPyEndAllowThreads(__tstate);
35046 if (PyErr_Occurred()) SWIG_fail;
35047 }
35048 resultobj = SWIG_From_int(static_cast< int >(result));
35049 return resultobj;
35050 fail:
35051 return NULL;
35052 }
35053
35054
35055 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35056 PyObject *resultobj = 0;
35057 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35058 void *argp1 = 0 ;
35059 int res1 = 0 ;
35060 PyObject *swig_obj[1] ;
35061
35062 if (!args) SWIG_fail;
35063 swig_obj[0] = args;
35064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35065 if (!SWIG_IsOK(res1)) {
35066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35067 }
35068 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35069 {
35070 PyThreadState* __tstate = wxPyBeginAllowThreads();
35071 (arg1)->OnLeave();
35072 wxPyEndAllowThreads(__tstate);
35073 if (PyErr_Occurred()) SWIG_fail;
35074 }
35075 resultobj = SWIG_Py_Void();
35076 return resultobj;
35077 fail:
35078 return NULL;
35079 }
35080
35081
35082 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35083 PyObject *resultobj = 0;
35084 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35085 int arg2 ;
35086 int arg3 ;
35087 bool result;
35088 void *argp1 = 0 ;
35089 int res1 = 0 ;
35090 int val2 ;
35091 int ecode2 = 0 ;
35092 int val3 ;
35093 int ecode3 = 0 ;
35094 PyObject * obj0 = 0 ;
35095 PyObject * obj1 = 0 ;
35096 PyObject * obj2 = 0 ;
35097 char * kwnames[] = {
35098 (char *) "self",(char *) "x",(char *) "y", NULL
35099 };
35100
35101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35103 if (!SWIG_IsOK(res1)) {
35104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35105 }
35106 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35107 ecode2 = SWIG_AsVal_int(obj1, &val2);
35108 if (!SWIG_IsOK(ecode2)) {
35109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35110 }
35111 arg2 = static_cast< int >(val2);
35112 ecode3 = SWIG_AsVal_int(obj2, &val3);
35113 if (!SWIG_IsOK(ecode3)) {
35114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35115 }
35116 arg3 = static_cast< int >(val3);
35117 {
35118 PyThreadState* __tstate = wxPyBeginAllowThreads();
35119 result = (bool)(arg1)->OnDrop(arg2,arg3);
35120 wxPyEndAllowThreads(__tstate);
35121 if (PyErr_Occurred()) SWIG_fail;
35122 }
35123 {
35124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35125 }
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35133 PyObject *resultobj = 0;
35134 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35135 int arg2 ;
35136 int arg3 ;
35137 wxDragResult arg4 ;
35138 wxDragResult result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 int val2 ;
35142 int ecode2 = 0 ;
35143 int val3 ;
35144 int ecode3 = 0 ;
35145 int val4 ;
35146 int ecode4 = 0 ;
35147 PyObject * obj0 = 0 ;
35148 PyObject * obj1 = 0 ;
35149 PyObject * obj2 = 0 ;
35150 PyObject * obj3 = 0 ;
35151 char * kwnames[] = {
35152 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35153 };
35154
35155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35157 if (!SWIG_IsOK(res1)) {
35158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35159 }
35160 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35161 ecode2 = SWIG_AsVal_int(obj1, &val2);
35162 if (!SWIG_IsOK(ecode2)) {
35163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35164 }
35165 arg2 = static_cast< int >(val2);
35166 ecode3 = SWIG_AsVal_int(obj2, &val3);
35167 if (!SWIG_IsOK(ecode3)) {
35168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35169 }
35170 arg3 = static_cast< int >(val3);
35171 ecode4 = SWIG_AsVal_int(obj3, &val4);
35172 if (!SWIG_IsOK(ecode4)) {
35173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35174 }
35175 arg4 = static_cast< wxDragResult >(val4);
35176 {
35177 PyThreadState* __tstate = wxPyBeginAllowThreads();
35178 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35179 wxPyEndAllowThreads(__tstate);
35180 if (PyErr_Occurred()) SWIG_fail;
35181 }
35182 resultobj = SWIG_From_int(static_cast< int >(result));
35183 return resultobj;
35184 fail:
35185 return NULL;
35186 }
35187
35188
35189 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35190 PyObject *obj;
35191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35192 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35193 return SWIG_Py_Void();
35194 }
35195
35196 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35197 return SWIG_Python_InitShadowInstance(args);
35198 }
35199
35200 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35201 PyObject *resultobj = 0;
35202 wxClipboard *result = 0 ;
35203
35204 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35205 {
35206 PyThreadState* __tstate = wxPyBeginAllowThreads();
35207 result = (wxClipboard *)new wxClipboard();
35208 wxPyEndAllowThreads(__tstate);
35209 if (PyErr_Occurred()) SWIG_fail;
35210 }
35211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35212 return resultobj;
35213 fail:
35214 return NULL;
35215 }
35216
35217
35218 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35219 PyObject *resultobj = 0;
35220 wxClipboard *arg1 = (wxClipboard *) 0 ;
35221 void *argp1 = 0 ;
35222 int res1 = 0 ;
35223 PyObject *swig_obj[1] ;
35224
35225 if (!args) SWIG_fail;
35226 swig_obj[0] = args;
35227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35228 if (!SWIG_IsOK(res1)) {
35229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35230 }
35231 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35232 {
35233 PyThreadState* __tstate = wxPyBeginAllowThreads();
35234 delete arg1;
35235
35236 wxPyEndAllowThreads(__tstate);
35237 if (PyErr_Occurred()) SWIG_fail;
35238 }
35239 resultobj = SWIG_Py_Void();
35240 return resultobj;
35241 fail:
35242 return NULL;
35243 }
35244
35245
35246 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35247 PyObject *resultobj = 0;
35248 wxClipboard *arg1 = (wxClipboard *) 0 ;
35249 bool result;
35250 void *argp1 = 0 ;
35251 int res1 = 0 ;
35252 PyObject *swig_obj[1] ;
35253
35254 if (!args) SWIG_fail;
35255 swig_obj[0] = args;
35256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35257 if (!SWIG_IsOK(res1)) {
35258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35259 }
35260 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35261 {
35262 PyThreadState* __tstate = wxPyBeginAllowThreads();
35263 result = (bool)(arg1)->Open();
35264 wxPyEndAllowThreads(__tstate);
35265 if (PyErr_Occurred()) SWIG_fail;
35266 }
35267 {
35268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35269 }
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35277 PyObject *resultobj = 0;
35278 wxClipboard *arg1 = (wxClipboard *) 0 ;
35279 void *argp1 = 0 ;
35280 int res1 = 0 ;
35281 PyObject *swig_obj[1] ;
35282
35283 if (!args) SWIG_fail;
35284 swig_obj[0] = args;
35285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35286 if (!SWIG_IsOK(res1)) {
35287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35288 }
35289 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35290 {
35291 PyThreadState* __tstate = wxPyBeginAllowThreads();
35292 (arg1)->Close();
35293 wxPyEndAllowThreads(__tstate);
35294 if (PyErr_Occurred()) SWIG_fail;
35295 }
35296 resultobj = SWIG_Py_Void();
35297 return resultobj;
35298 fail:
35299 return NULL;
35300 }
35301
35302
35303 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35304 PyObject *resultobj = 0;
35305 wxClipboard *arg1 = (wxClipboard *) 0 ;
35306 bool result;
35307 void *argp1 = 0 ;
35308 int res1 = 0 ;
35309 PyObject *swig_obj[1] ;
35310
35311 if (!args) SWIG_fail;
35312 swig_obj[0] = args;
35313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35314 if (!SWIG_IsOK(res1)) {
35315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35316 }
35317 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35318 {
35319 PyThreadState* __tstate = wxPyBeginAllowThreads();
35320 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35321 wxPyEndAllowThreads(__tstate);
35322 if (PyErr_Occurred()) SWIG_fail;
35323 }
35324 {
35325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35326 }
35327 return resultobj;
35328 fail:
35329 return NULL;
35330 }
35331
35332
35333 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35334 PyObject *resultobj = 0;
35335 wxClipboard *arg1 = (wxClipboard *) 0 ;
35336 wxDataObject *arg2 = (wxDataObject *) 0 ;
35337 bool result;
35338 void *argp1 = 0 ;
35339 int res1 = 0 ;
35340 int res2 = 0 ;
35341 PyObject * obj0 = 0 ;
35342 PyObject * obj1 = 0 ;
35343 char * kwnames[] = {
35344 (char *) "self",(char *) "data", NULL
35345 };
35346
35347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35349 if (!SWIG_IsOK(res1)) {
35350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35351 }
35352 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35353 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35354 if (!SWIG_IsOK(res2)) {
35355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35356 }
35357 {
35358 PyThreadState* __tstate = wxPyBeginAllowThreads();
35359 result = (bool)(arg1)->AddData(arg2);
35360 wxPyEndAllowThreads(__tstate);
35361 if (PyErr_Occurred()) SWIG_fail;
35362 }
35363 {
35364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35365 }
35366 return resultobj;
35367 fail:
35368 return NULL;
35369 }
35370
35371
35372 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35373 PyObject *resultobj = 0;
35374 wxClipboard *arg1 = (wxClipboard *) 0 ;
35375 wxDataObject *arg2 = (wxDataObject *) 0 ;
35376 bool result;
35377 void *argp1 = 0 ;
35378 int res1 = 0 ;
35379 int res2 = 0 ;
35380 PyObject * obj0 = 0 ;
35381 PyObject * obj1 = 0 ;
35382 char * kwnames[] = {
35383 (char *) "self",(char *) "data", NULL
35384 };
35385
35386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35388 if (!SWIG_IsOK(res1)) {
35389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35390 }
35391 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35392 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35393 if (!SWIG_IsOK(res2)) {
35394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35395 }
35396 {
35397 PyThreadState* __tstate = wxPyBeginAllowThreads();
35398 result = (bool)(arg1)->SetData(arg2);
35399 wxPyEndAllowThreads(__tstate);
35400 if (PyErr_Occurred()) SWIG_fail;
35401 }
35402 {
35403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35404 }
35405 return resultobj;
35406 fail:
35407 return NULL;
35408 }
35409
35410
35411 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35412 PyObject *resultobj = 0;
35413 wxClipboard *arg1 = (wxClipboard *) 0 ;
35414 wxDataFormat *arg2 = 0 ;
35415 bool result;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 void *argp2 = 0 ;
35419 int res2 = 0 ;
35420 PyObject * obj0 = 0 ;
35421 PyObject * obj1 = 0 ;
35422 char * kwnames[] = {
35423 (char *) "self",(char *) "format", NULL
35424 };
35425
35426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35428 if (!SWIG_IsOK(res1)) {
35429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35430 }
35431 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35432 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35433 if (!SWIG_IsOK(res2)) {
35434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35435 }
35436 if (!argp2) {
35437 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35438 }
35439 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35440 {
35441 PyThreadState* __tstate = wxPyBeginAllowThreads();
35442 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35443 wxPyEndAllowThreads(__tstate);
35444 if (PyErr_Occurred()) SWIG_fail;
35445 }
35446 {
35447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35448 }
35449 return resultobj;
35450 fail:
35451 return NULL;
35452 }
35453
35454
35455 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35456 PyObject *resultobj = 0;
35457 wxClipboard *arg1 = (wxClipboard *) 0 ;
35458 wxDataObject *arg2 = 0 ;
35459 bool result;
35460 void *argp1 = 0 ;
35461 int res1 = 0 ;
35462 void *argp2 = 0 ;
35463 int res2 = 0 ;
35464 PyObject * obj0 = 0 ;
35465 PyObject * obj1 = 0 ;
35466 char * kwnames[] = {
35467 (char *) "self",(char *) "data", NULL
35468 };
35469
35470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35472 if (!SWIG_IsOK(res1)) {
35473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35474 }
35475 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35476 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35477 if (!SWIG_IsOK(res2)) {
35478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35479 }
35480 if (!argp2) {
35481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35482 }
35483 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 result = (bool)(arg1)->GetData(*arg2);
35487 wxPyEndAllowThreads(__tstate);
35488 if (PyErr_Occurred()) SWIG_fail;
35489 }
35490 {
35491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35492 }
35493 return resultobj;
35494 fail:
35495 return NULL;
35496 }
35497
35498
35499 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35500 PyObject *resultobj = 0;
35501 wxClipboard *arg1 = (wxClipboard *) 0 ;
35502 void *argp1 = 0 ;
35503 int res1 = 0 ;
35504 PyObject *swig_obj[1] ;
35505
35506 if (!args) SWIG_fail;
35507 swig_obj[0] = args;
35508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35509 if (!SWIG_IsOK(res1)) {
35510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35511 }
35512 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35513 {
35514 PyThreadState* __tstate = wxPyBeginAllowThreads();
35515 (arg1)->Clear();
35516 wxPyEndAllowThreads(__tstate);
35517 if (PyErr_Occurred()) SWIG_fail;
35518 }
35519 resultobj = SWIG_Py_Void();
35520 return resultobj;
35521 fail:
35522 return NULL;
35523 }
35524
35525
35526 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35527 PyObject *resultobj = 0;
35528 wxClipboard *arg1 = (wxClipboard *) 0 ;
35529 bool result;
35530 void *argp1 = 0 ;
35531 int res1 = 0 ;
35532 PyObject *swig_obj[1] ;
35533
35534 if (!args) SWIG_fail;
35535 swig_obj[0] = args;
35536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35537 if (!SWIG_IsOK(res1)) {
35538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35539 }
35540 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35541 {
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 result = (bool)(arg1)->Flush();
35544 wxPyEndAllowThreads(__tstate);
35545 if (PyErr_Occurred()) SWIG_fail;
35546 }
35547 {
35548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35549 }
35550 return resultobj;
35551 fail:
35552 return NULL;
35553 }
35554
35555
35556 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35557 PyObject *resultobj = 0;
35558 wxClipboard *arg1 = (wxClipboard *) 0 ;
35559 bool arg2 = (bool) true ;
35560 void *argp1 = 0 ;
35561 int res1 = 0 ;
35562 bool val2 ;
35563 int ecode2 = 0 ;
35564 PyObject * obj0 = 0 ;
35565 PyObject * obj1 = 0 ;
35566 char * kwnames[] = {
35567 (char *) "self",(char *) "primary", NULL
35568 };
35569
35570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35572 if (!SWIG_IsOK(res1)) {
35573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35574 }
35575 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35576 if (obj1) {
35577 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35578 if (!SWIG_IsOK(ecode2)) {
35579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35580 }
35581 arg2 = static_cast< bool >(val2);
35582 }
35583 {
35584 PyThreadState* __tstate = wxPyBeginAllowThreads();
35585 (arg1)->UsePrimarySelection(arg2);
35586 wxPyEndAllowThreads(__tstate);
35587 if (PyErr_Occurred()) SWIG_fail;
35588 }
35589 resultobj = SWIG_Py_Void();
35590 return resultobj;
35591 fail:
35592 return NULL;
35593 }
35594
35595
35596 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35597 PyObject *resultobj = 0;
35598 wxClipboard *result = 0 ;
35599
35600 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35601 {
35602 PyThreadState* __tstate = wxPyBeginAllowThreads();
35603 result = (wxClipboard *)wxClipboard::Get();
35604 wxPyEndAllowThreads(__tstate);
35605 if (PyErr_Occurred()) SWIG_fail;
35606 }
35607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35608 return resultobj;
35609 fail:
35610 return NULL;
35611 }
35612
35613
35614 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35615 PyObject *obj;
35616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35617 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35618 return SWIG_Py_Void();
35619 }
35620
35621 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35622 return SWIG_Python_InitShadowInstance(args);
35623 }
35624
35625 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35626 PyObject *resultobj = 0;
35627 wxClipboard *arg1 = (wxClipboard *) NULL ;
35628 wxClipboardLocker *result = 0 ;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 PyObject * obj0 = 0 ;
35632 char * kwnames[] = {
35633 (char *) "clipboard", NULL
35634 };
35635
35636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35637 if (obj0) {
35638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35639 if (!SWIG_IsOK(res1)) {
35640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35641 }
35642 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35643 }
35644 {
35645 PyThreadState* __tstate = wxPyBeginAllowThreads();
35646 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35647 wxPyEndAllowThreads(__tstate);
35648 if (PyErr_Occurred()) SWIG_fail;
35649 }
35650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35651 return resultobj;
35652 fail:
35653 return NULL;
35654 }
35655
35656
35657 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35658 PyObject *resultobj = 0;
35659 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35660 void *argp1 = 0 ;
35661 int res1 = 0 ;
35662 PyObject *swig_obj[1] ;
35663
35664 if (!args) SWIG_fail;
35665 swig_obj[0] = args;
35666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35667 if (!SWIG_IsOK(res1)) {
35668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35669 }
35670 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35671 {
35672 PyThreadState* __tstate = wxPyBeginAllowThreads();
35673 delete arg1;
35674
35675 wxPyEndAllowThreads(__tstate);
35676 if (PyErr_Occurred()) SWIG_fail;
35677 }
35678 resultobj = SWIG_Py_Void();
35679 return resultobj;
35680 fail:
35681 return NULL;
35682 }
35683
35684
35685 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35686 PyObject *resultobj = 0;
35687 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35688 bool result;
35689 void *argp1 = 0 ;
35690 int res1 = 0 ;
35691 PyObject *swig_obj[1] ;
35692
35693 if (!args) SWIG_fail;
35694 swig_obj[0] = args;
35695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35696 if (!SWIG_IsOK(res1)) {
35697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35698 }
35699 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35700 {
35701 PyThreadState* __tstate = wxPyBeginAllowThreads();
35702 result = (bool)wxClipboardLocker___nonzero__(arg1);
35703 wxPyEndAllowThreads(__tstate);
35704 if (PyErr_Occurred()) SWIG_fail;
35705 }
35706 {
35707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35708 }
35709 return resultobj;
35710 fail:
35711 return NULL;
35712 }
35713
35714
35715 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35716 PyObject *obj;
35717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35718 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35719 return SWIG_Py_Void();
35720 }
35721
35722 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35723 return SWIG_Python_InitShadowInstance(args);
35724 }
35725
35726 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35727 PyObject *resultobj = 0;
35728 int arg1 = (int) 0 ;
35729 int arg2 = (int) 0 ;
35730 int arg3 = (int) 0 ;
35731 int arg4 = (int) 0 ;
35732 wxVideoMode *result = 0 ;
35733 int val1 ;
35734 int ecode1 = 0 ;
35735 int val2 ;
35736 int ecode2 = 0 ;
35737 int val3 ;
35738 int ecode3 = 0 ;
35739 int val4 ;
35740 int ecode4 = 0 ;
35741 PyObject * obj0 = 0 ;
35742 PyObject * obj1 = 0 ;
35743 PyObject * obj2 = 0 ;
35744 PyObject * obj3 = 0 ;
35745 char * kwnames[] = {
35746 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35747 };
35748
35749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35750 if (obj0) {
35751 ecode1 = SWIG_AsVal_int(obj0, &val1);
35752 if (!SWIG_IsOK(ecode1)) {
35753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35754 }
35755 arg1 = static_cast< int >(val1);
35756 }
35757 if (obj1) {
35758 ecode2 = SWIG_AsVal_int(obj1, &val2);
35759 if (!SWIG_IsOK(ecode2)) {
35760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35761 }
35762 arg2 = static_cast< int >(val2);
35763 }
35764 if (obj2) {
35765 ecode3 = SWIG_AsVal_int(obj2, &val3);
35766 if (!SWIG_IsOK(ecode3)) {
35767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35768 }
35769 arg3 = static_cast< int >(val3);
35770 }
35771 if (obj3) {
35772 ecode4 = SWIG_AsVal_int(obj3, &val4);
35773 if (!SWIG_IsOK(ecode4)) {
35774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35775 }
35776 arg4 = static_cast< int >(val4);
35777 }
35778 {
35779 PyThreadState* __tstate = wxPyBeginAllowThreads();
35780 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35792 PyObject *resultobj = 0;
35793 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35794 void *argp1 = 0 ;
35795 int res1 = 0 ;
35796 PyObject *swig_obj[1] ;
35797
35798 if (!args) SWIG_fail;
35799 swig_obj[0] = args;
35800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35801 if (!SWIG_IsOK(res1)) {
35802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35803 }
35804 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 delete arg1;
35808
35809 wxPyEndAllowThreads(__tstate);
35810 if (PyErr_Occurred()) SWIG_fail;
35811 }
35812 resultobj = SWIG_Py_Void();
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj = 0;
35821 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35822 wxVideoMode *arg2 = 0 ;
35823 bool result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 void *argp2 = 0 ;
35827 int res2 = 0 ;
35828 PyObject * obj0 = 0 ;
35829 PyObject * obj1 = 0 ;
35830 char * kwnames[] = {
35831 (char *) "self",(char *) "other", NULL
35832 };
35833
35834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35836 if (!SWIG_IsOK(res1)) {
35837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35838 }
35839 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35841 if (!SWIG_IsOK(res2)) {
35842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35843 }
35844 if (!argp2) {
35845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35846 }
35847 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35848 {
35849 PyThreadState* __tstate = wxPyBeginAllowThreads();
35850 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35851 wxPyEndAllowThreads(__tstate);
35852 if (PyErr_Occurred()) SWIG_fail;
35853 }
35854 {
35855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35856 }
35857 return resultobj;
35858 fail:
35859 return NULL;
35860 }
35861
35862
35863 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35864 PyObject *resultobj = 0;
35865 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35866 int result;
35867 void *argp1 = 0 ;
35868 int res1 = 0 ;
35869 PyObject *swig_obj[1] ;
35870
35871 if (!args) SWIG_fail;
35872 swig_obj[0] = args;
35873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35874 if (!SWIG_IsOK(res1)) {
35875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35876 }
35877 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35878 {
35879 PyThreadState* __tstate = wxPyBeginAllowThreads();
35880 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35881 wxPyEndAllowThreads(__tstate);
35882 if (PyErr_Occurred()) SWIG_fail;
35883 }
35884 resultobj = SWIG_From_int(static_cast< int >(result));
35885 return resultobj;
35886 fail:
35887 return NULL;
35888 }
35889
35890
35891 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35892 PyObject *resultobj = 0;
35893 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35894 int result;
35895 void *argp1 = 0 ;
35896 int res1 = 0 ;
35897 PyObject *swig_obj[1] ;
35898
35899 if (!args) SWIG_fail;
35900 swig_obj[0] = args;
35901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35902 if (!SWIG_IsOK(res1)) {
35903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35904 }
35905 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35906 {
35907 PyThreadState* __tstate = wxPyBeginAllowThreads();
35908 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35909 wxPyEndAllowThreads(__tstate);
35910 if (PyErr_Occurred()) SWIG_fail;
35911 }
35912 resultobj = SWIG_From_int(static_cast< int >(result));
35913 return resultobj;
35914 fail:
35915 return NULL;
35916 }
35917
35918
35919 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35920 PyObject *resultobj = 0;
35921 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35922 int result;
35923 void *argp1 = 0 ;
35924 int res1 = 0 ;
35925 PyObject *swig_obj[1] ;
35926
35927 if (!args) SWIG_fail;
35928 swig_obj[0] = args;
35929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35930 if (!SWIG_IsOK(res1)) {
35931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35932 }
35933 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35934 {
35935 PyThreadState* __tstate = wxPyBeginAllowThreads();
35936 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35937 wxPyEndAllowThreads(__tstate);
35938 if (PyErr_Occurred()) SWIG_fail;
35939 }
35940 resultobj = SWIG_From_int(static_cast< int >(result));
35941 return resultobj;
35942 fail:
35943 return NULL;
35944 }
35945
35946
35947 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35948 PyObject *resultobj = 0;
35949 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35950 bool result;
35951 void *argp1 = 0 ;
35952 int res1 = 0 ;
35953 PyObject *swig_obj[1] ;
35954
35955 if (!args) SWIG_fail;
35956 swig_obj[0] = args;
35957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35958 if (!SWIG_IsOK(res1)) {
35959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35960 }
35961 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35962 {
35963 PyThreadState* __tstate = wxPyBeginAllowThreads();
35964 result = (bool)((wxVideoMode const *)arg1)->IsOk();
35965 wxPyEndAllowThreads(__tstate);
35966 if (PyErr_Occurred()) SWIG_fail;
35967 }
35968 {
35969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35970 }
35971 return resultobj;
35972 fail:
35973 return NULL;
35974 }
35975
35976
35977 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35978 PyObject *resultobj = 0;
35979 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35980 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35981 bool result;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 void *argp2 = 0 ;
35985 int res2 = 0 ;
35986 PyObject * obj0 = 0 ;
35987 PyObject * obj1 = 0 ;
35988 char * kwnames[] = {
35989 (char *) "self",(char *) "other", NULL
35990 };
35991
35992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
35993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35994 if (!SWIG_IsOK(res1)) {
35995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35996 }
35997 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35999 if (!SWIG_IsOK(res2)) {
36000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36001 }
36002 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 {
36010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36011 }
36012 return resultobj;
36013 fail:
36014 return NULL;
36015 }
36016
36017
36018 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36019 PyObject *resultobj = 0;
36020 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36021 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36022 bool result;
36023 void *argp1 = 0 ;
36024 int res1 = 0 ;
36025 void *argp2 = 0 ;
36026 int res2 = 0 ;
36027 PyObject * obj0 = 0 ;
36028 PyObject * obj1 = 0 ;
36029 char * kwnames[] = {
36030 (char *) "self",(char *) "other", NULL
36031 };
36032
36033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36035 if (!SWIG_IsOK(res1)) {
36036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36037 }
36038 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36040 if (!SWIG_IsOK(res2)) {
36041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36042 }
36043 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36044 {
36045 PyThreadState* __tstate = wxPyBeginAllowThreads();
36046 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36047 wxPyEndAllowThreads(__tstate);
36048 if (PyErr_Occurred()) SWIG_fail;
36049 }
36050 {
36051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36052 }
36053 return resultobj;
36054 fail:
36055 return NULL;
36056 }
36057
36058
36059 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36060 PyObject *resultobj = 0;
36061 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36062 int arg2 ;
36063 void *argp1 = 0 ;
36064 int res1 = 0 ;
36065 int val2 ;
36066 int ecode2 = 0 ;
36067 PyObject *swig_obj[2] ;
36068
36069 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36071 if (!SWIG_IsOK(res1)) {
36072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36073 }
36074 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36075 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36076 if (!SWIG_IsOK(ecode2)) {
36077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36078 }
36079 arg2 = static_cast< int >(val2);
36080 if (arg1) (arg1)->w = arg2;
36081
36082 resultobj = SWIG_Py_Void();
36083 return resultobj;
36084 fail:
36085 return NULL;
36086 }
36087
36088
36089 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36090 PyObject *resultobj = 0;
36091 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36092 int result;
36093 void *argp1 = 0 ;
36094 int res1 = 0 ;
36095 PyObject *swig_obj[1] ;
36096
36097 if (!args) SWIG_fail;
36098 swig_obj[0] = args;
36099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36100 if (!SWIG_IsOK(res1)) {
36101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36102 }
36103 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36104 result = (int) ((arg1)->w);
36105 resultobj = SWIG_From_int(static_cast< int >(result));
36106 return resultobj;
36107 fail:
36108 return NULL;
36109 }
36110
36111
36112 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36113 PyObject *resultobj = 0;
36114 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36115 int arg2 ;
36116 void *argp1 = 0 ;
36117 int res1 = 0 ;
36118 int val2 ;
36119 int ecode2 = 0 ;
36120 PyObject *swig_obj[2] ;
36121
36122 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36124 if (!SWIG_IsOK(res1)) {
36125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36126 }
36127 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36128 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36129 if (!SWIG_IsOK(ecode2)) {
36130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36131 }
36132 arg2 = static_cast< int >(val2);
36133 if (arg1) (arg1)->h = arg2;
36134
36135 resultobj = SWIG_Py_Void();
36136 return resultobj;
36137 fail:
36138 return NULL;
36139 }
36140
36141
36142 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36143 PyObject *resultobj = 0;
36144 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36145 int result;
36146 void *argp1 = 0 ;
36147 int res1 = 0 ;
36148 PyObject *swig_obj[1] ;
36149
36150 if (!args) SWIG_fail;
36151 swig_obj[0] = args;
36152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36153 if (!SWIG_IsOK(res1)) {
36154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36155 }
36156 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36157 result = (int) ((arg1)->h);
36158 resultobj = SWIG_From_int(static_cast< int >(result));
36159 return resultobj;
36160 fail:
36161 return NULL;
36162 }
36163
36164
36165 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36166 PyObject *resultobj = 0;
36167 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36168 int arg2 ;
36169 void *argp1 = 0 ;
36170 int res1 = 0 ;
36171 int val2 ;
36172 int ecode2 = 0 ;
36173 PyObject *swig_obj[2] ;
36174
36175 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36177 if (!SWIG_IsOK(res1)) {
36178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36179 }
36180 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36181 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36182 if (!SWIG_IsOK(ecode2)) {
36183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36184 }
36185 arg2 = static_cast< int >(val2);
36186 if (arg1) (arg1)->bpp = arg2;
36187
36188 resultobj = SWIG_Py_Void();
36189 return resultobj;
36190 fail:
36191 return NULL;
36192 }
36193
36194
36195 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36196 PyObject *resultobj = 0;
36197 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36198 int result;
36199 void *argp1 = 0 ;
36200 int res1 = 0 ;
36201 PyObject *swig_obj[1] ;
36202
36203 if (!args) SWIG_fail;
36204 swig_obj[0] = args;
36205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36206 if (!SWIG_IsOK(res1)) {
36207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36208 }
36209 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36210 result = (int) ((arg1)->bpp);
36211 resultobj = SWIG_From_int(static_cast< int >(result));
36212 return resultobj;
36213 fail:
36214 return NULL;
36215 }
36216
36217
36218 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36219 PyObject *resultobj = 0;
36220 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36221 int arg2 ;
36222 void *argp1 = 0 ;
36223 int res1 = 0 ;
36224 int val2 ;
36225 int ecode2 = 0 ;
36226 PyObject *swig_obj[2] ;
36227
36228 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36230 if (!SWIG_IsOK(res1)) {
36231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36232 }
36233 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36234 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36235 if (!SWIG_IsOK(ecode2)) {
36236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36237 }
36238 arg2 = static_cast< int >(val2);
36239 if (arg1) (arg1)->refresh = arg2;
36240
36241 resultobj = SWIG_Py_Void();
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36249 PyObject *resultobj = 0;
36250 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36251 int result;
36252 void *argp1 = 0 ;
36253 int res1 = 0 ;
36254 PyObject *swig_obj[1] ;
36255
36256 if (!args) SWIG_fail;
36257 swig_obj[0] = args;
36258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36259 if (!SWIG_IsOK(res1)) {
36260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36261 }
36262 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36263 result = (int) ((arg1)->refresh);
36264 resultobj = SWIG_From_int(static_cast< int >(result));
36265 return resultobj;
36266 fail:
36267 return NULL;
36268 }
36269
36270
36271 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36272 PyObject *obj;
36273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36274 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36275 return SWIG_Py_Void();
36276 }
36277
36278 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36279 return SWIG_Python_InitShadowInstance(args);
36280 }
36281
36282 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36283 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36284 return 1;
36285 }
36286
36287
36288 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36289 PyObject *pyobj = 0;
36290
36291 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36292 return pyobj;
36293 }
36294
36295
36296 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36297 PyObject *resultobj = 0;
36298 unsigned int arg1 = (unsigned int) 0 ;
36299 wxDisplay *result = 0 ;
36300 unsigned int val1 ;
36301 int ecode1 = 0 ;
36302 PyObject * obj0 = 0 ;
36303 char * kwnames[] = {
36304 (char *) "index", NULL
36305 };
36306
36307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36308 if (obj0) {
36309 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36310 if (!SWIG_IsOK(ecode1)) {
36311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36312 }
36313 arg1 = static_cast< unsigned int >(val1);
36314 }
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (wxDisplay *)new wxDisplay(arg1);
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36329 PyObject *resultobj = 0;
36330 wxDisplay *arg1 = (wxDisplay *) 0 ;
36331 void *argp1 = 0 ;
36332 int res1 = 0 ;
36333 PyObject *swig_obj[1] ;
36334
36335 if (!args) SWIG_fail;
36336 swig_obj[0] = args;
36337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36338 if (!SWIG_IsOK(res1)) {
36339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36340 }
36341 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36342 {
36343 PyThreadState* __tstate = wxPyBeginAllowThreads();
36344 delete arg1;
36345
36346 wxPyEndAllowThreads(__tstate);
36347 if (PyErr_Occurred()) SWIG_fail;
36348 }
36349 resultobj = SWIG_Py_Void();
36350 return resultobj;
36351 fail:
36352 return NULL;
36353 }
36354
36355
36356 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36357 PyObject *resultobj = 0;
36358 unsigned int result;
36359
36360 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36361 {
36362 PyThreadState* __tstate = wxPyBeginAllowThreads();
36363 result = (unsigned int)wxDisplay::GetCount();
36364 wxPyEndAllowThreads(__tstate);
36365 if (PyErr_Occurred()) SWIG_fail;
36366 }
36367 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36368 return resultobj;
36369 fail:
36370 return NULL;
36371 }
36372
36373
36374 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36375 PyObject *resultobj = 0;
36376 wxPoint *arg1 = 0 ;
36377 int result;
36378 wxPoint temp1 ;
36379 PyObject * obj0 = 0 ;
36380 char * kwnames[] = {
36381 (char *) "pt", NULL
36382 };
36383
36384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36385 {
36386 arg1 = &temp1;
36387 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36388 }
36389 {
36390 PyThreadState* __tstate = wxPyBeginAllowThreads();
36391 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36392 wxPyEndAllowThreads(__tstate);
36393 if (PyErr_Occurred()) SWIG_fail;
36394 }
36395 resultobj = SWIG_From_int(static_cast< int >(result));
36396 return resultobj;
36397 fail:
36398 return NULL;
36399 }
36400
36401
36402 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36403 PyObject *resultobj = 0;
36404 wxWindow *arg1 = (wxWindow *) 0 ;
36405 int result;
36406 void *argp1 = 0 ;
36407 int res1 = 0 ;
36408 PyObject * obj0 = 0 ;
36409 char * kwnames[] = {
36410 (char *) "window", NULL
36411 };
36412
36413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36415 if (!SWIG_IsOK(res1)) {
36416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36417 }
36418 arg1 = reinterpret_cast< wxWindow * >(argp1);
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = (int)wxDisplay::GetFromWindow(arg1);
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 resultobj = SWIG_From_int(static_cast< int >(result));
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36433 PyObject *resultobj = 0;
36434 wxDisplay *arg1 = (wxDisplay *) 0 ;
36435 bool result;
36436 void *argp1 = 0 ;
36437 int res1 = 0 ;
36438 PyObject *swig_obj[1] ;
36439
36440 if (!args) SWIG_fail;
36441 swig_obj[0] = args;
36442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36443 if (!SWIG_IsOK(res1)) {
36444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36445 }
36446 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 result = (bool)((wxDisplay const *)arg1)->IsOk();
36450 wxPyEndAllowThreads(__tstate);
36451 if (PyErr_Occurred()) SWIG_fail;
36452 }
36453 {
36454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36455 }
36456 return resultobj;
36457 fail:
36458 return NULL;
36459 }
36460
36461
36462 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36463 PyObject *resultobj = 0;
36464 wxDisplay *arg1 = (wxDisplay *) 0 ;
36465 wxRect result;
36466 void *argp1 = 0 ;
36467 int res1 = 0 ;
36468 PyObject *swig_obj[1] ;
36469
36470 if (!args) SWIG_fail;
36471 swig_obj[0] = args;
36472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36473 if (!SWIG_IsOK(res1)) {
36474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36475 }
36476 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36477 {
36478 PyThreadState* __tstate = wxPyBeginAllowThreads();
36479 result = ((wxDisplay const *)arg1)->GetGeometry();
36480 wxPyEndAllowThreads(__tstate);
36481 if (PyErr_Occurred()) SWIG_fail;
36482 }
36483 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36484 return resultobj;
36485 fail:
36486 return NULL;
36487 }
36488
36489
36490 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36491 PyObject *resultobj = 0;
36492 wxDisplay *arg1 = (wxDisplay *) 0 ;
36493 wxRect result;
36494 void *argp1 = 0 ;
36495 int res1 = 0 ;
36496 PyObject *swig_obj[1] ;
36497
36498 if (!args) SWIG_fail;
36499 swig_obj[0] = args;
36500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36501 if (!SWIG_IsOK(res1)) {
36502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36503 }
36504 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 result = ((wxDisplay const *)arg1)->GetClientArea();
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36512 return resultobj;
36513 fail:
36514 return NULL;
36515 }
36516
36517
36518 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36519 PyObject *resultobj = 0;
36520 wxDisplay *arg1 = (wxDisplay *) 0 ;
36521 wxString result;
36522 void *argp1 = 0 ;
36523 int res1 = 0 ;
36524 PyObject *swig_obj[1] ;
36525
36526 if (!args) SWIG_fail;
36527 swig_obj[0] = args;
36528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36529 if (!SWIG_IsOK(res1)) {
36530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36531 }
36532 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36533 {
36534 PyThreadState* __tstate = wxPyBeginAllowThreads();
36535 result = ((wxDisplay const *)arg1)->GetName();
36536 wxPyEndAllowThreads(__tstate);
36537 if (PyErr_Occurred()) SWIG_fail;
36538 }
36539 {
36540 #if wxUSE_UNICODE
36541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36542 #else
36543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36544 #endif
36545 }
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36553 PyObject *resultobj = 0;
36554 wxDisplay *arg1 = (wxDisplay *) 0 ;
36555 bool result;
36556 void *argp1 = 0 ;
36557 int res1 = 0 ;
36558 PyObject *swig_obj[1] ;
36559
36560 if (!args) SWIG_fail;
36561 swig_obj[0] = args;
36562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36563 if (!SWIG_IsOK(res1)) {
36564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36565 }
36566 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36567 {
36568 PyThreadState* __tstate = wxPyBeginAllowThreads();
36569 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36570 wxPyEndAllowThreads(__tstate);
36571 if (PyErr_Occurred()) SWIG_fail;
36572 }
36573 {
36574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36575 }
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36583 PyObject *resultobj = 0;
36584 wxDisplay *arg1 = (wxDisplay *) 0 ;
36585 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36586 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36587 PyObject *result = 0 ;
36588 void *argp1 = 0 ;
36589 int res1 = 0 ;
36590 void *argp2 = 0 ;
36591 int res2 = 0 ;
36592 PyObject * obj0 = 0 ;
36593 PyObject * obj1 = 0 ;
36594 char * kwnames[] = {
36595 (char *) "self",(char *) "mode", NULL
36596 };
36597
36598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36600 if (!SWIG_IsOK(res1)) {
36601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36602 }
36603 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36604 if (obj1) {
36605 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36606 if (!SWIG_IsOK(res2)) {
36607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36608 }
36609 if (!argp2) {
36610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36611 }
36612 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36613 }
36614 {
36615 PyThreadState* __tstate = wxPyBeginAllowThreads();
36616 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36617 wxPyEndAllowThreads(__tstate);
36618 if (PyErr_Occurred()) SWIG_fail;
36619 }
36620 resultobj = result;
36621 return resultobj;
36622 fail:
36623 return NULL;
36624 }
36625
36626
36627 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36628 PyObject *resultobj = 0;
36629 wxDisplay *arg1 = (wxDisplay *) 0 ;
36630 wxVideoMode result;
36631 void *argp1 = 0 ;
36632 int res1 = 0 ;
36633 PyObject *swig_obj[1] ;
36634
36635 if (!args) SWIG_fail;
36636 swig_obj[0] = args;
36637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36638 if (!SWIG_IsOK(res1)) {
36639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36640 }
36641 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36642 {
36643 PyThreadState* __tstate = wxPyBeginAllowThreads();
36644 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36645 wxPyEndAllowThreads(__tstate);
36646 if (PyErr_Occurred()) SWIG_fail;
36647 }
36648 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36649 return resultobj;
36650 fail:
36651 return NULL;
36652 }
36653
36654
36655 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36656 PyObject *resultobj = 0;
36657 wxDisplay *arg1 = (wxDisplay *) 0 ;
36658 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36659 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36660 bool result;
36661 void *argp1 = 0 ;
36662 int res1 = 0 ;
36663 void *argp2 = 0 ;
36664 int res2 = 0 ;
36665 PyObject * obj0 = 0 ;
36666 PyObject * obj1 = 0 ;
36667 char * kwnames[] = {
36668 (char *) "self",(char *) "mode", NULL
36669 };
36670
36671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36673 if (!SWIG_IsOK(res1)) {
36674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36675 }
36676 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36677 if (obj1) {
36678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36679 if (!SWIG_IsOK(res2)) {
36680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36681 }
36682 if (!argp2) {
36683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36684 }
36685 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36686 }
36687 {
36688 PyThreadState* __tstate = wxPyBeginAllowThreads();
36689 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36690 wxPyEndAllowThreads(__tstate);
36691 if (PyErr_Occurred()) SWIG_fail;
36692 }
36693 {
36694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36695 }
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36703 PyObject *resultobj = 0;
36704 wxDisplay *arg1 = (wxDisplay *) 0 ;
36705 void *argp1 = 0 ;
36706 int res1 = 0 ;
36707 PyObject *swig_obj[1] ;
36708
36709 if (!args) SWIG_fail;
36710 swig_obj[0] = args;
36711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36712 if (!SWIG_IsOK(res1)) {
36713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36714 }
36715 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36716 {
36717 PyThreadState* __tstate = wxPyBeginAllowThreads();
36718 wxDisplay_ResetMode(arg1);
36719 wxPyEndAllowThreads(__tstate);
36720 if (PyErr_Occurred()) SWIG_fail;
36721 }
36722 resultobj = SWIG_Py_Void();
36723 return resultobj;
36724 fail:
36725 return NULL;
36726 }
36727
36728
36729 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36730 PyObject *obj;
36731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36732 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36733 return SWIG_Py_Void();
36734 }
36735
36736 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36737 return SWIG_Python_InitShadowInstance(args);
36738 }
36739
36740 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36741 PyObject *resultobj = 0;
36742 wxStandardPaths *result = 0 ;
36743
36744 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36745 {
36746 PyThreadState* __tstate = wxPyBeginAllowThreads();
36747 result = (wxStandardPaths *)wxStandardPaths_Get();
36748 wxPyEndAllowThreads(__tstate);
36749 if (PyErr_Occurred()) SWIG_fail;
36750 }
36751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36752 return resultobj;
36753 fail:
36754 return NULL;
36755 }
36756
36757
36758 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36759 PyObject *resultobj = 0;
36760 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36761 wxString result;
36762 void *argp1 = 0 ;
36763 int res1 = 0 ;
36764 PyObject *swig_obj[1] ;
36765
36766 if (!args) SWIG_fail;
36767 swig_obj[0] = args;
36768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36769 if (!SWIG_IsOK(res1)) {
36770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36771 }
36772 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36773 {
36774 PyThreadState* __tstate = wxPyBeginAllowThreads();
36775 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 {
36780 #if wxUSE_UNICODE
36781 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36782 #else
36783 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36784 #endif
36785 }
36786 return resultobj;
36787 fail:
36788 return NULL;
36789 }
36790
36791
36792 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36793 PyObject *resultobj = 0;
36794 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36795 wxString result;
36796 void *argp1 = 0 ;
36797 int res1 = 0 ;
36798 PyObject *swig_obj[1] ;
36799
36800 if (!args) SWIG_fail;
36801 swig_obj[0] = args;
36802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36803 if (!SWIG_IsOK(res1)) {
36804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36805 }
36806 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36807 {
36808 PyThreadState* __tstate = wxPyBeginAllowThreads();
36809 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36810 wxPyEndAllowThreads(__tstate);
36811 if (PyErr_Occurred()) SWIG_fail;
36812 }
36813 {
36814 #if wxUSE_UNICODE
36815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36816 #else
36817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36818 #endif
36819 }
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36827 PyObject *resultobj = 0;
36828 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36829 wxString result;
36830 void *argp1 = 0 ;
36831 int res1 = 0 ;
36832 PyObject *swig_obj[1] ;
36833
36834 if (!args) SWIG_fail;
36835 swig_obj[0] = args;
36836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36837 if (!SWIG_IsOK(res1)) {
36838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36839 }
36840 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 {
36848 #if wxUSE_UNICODE
36849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36850 #else
36851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36852 #endif
36853 }
36854 return resultobj;
36855 fail:
36856 return NULL;
36857 }
36858
36859
36860 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36861 PyObject *resultobj = 0;
36862 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36863 wxString result;
36864 void *argp1 = 0 ;
36865 int res1 = 0 ;
36866 PyObject *swig_obj[1] ;
36867
36868 if (!args) SWIG_fail;
36869 swig_obj[0] = args;
36870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36871 if (!SWIG_IsOK(res1)) {
36872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36873 }
36874 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36875 {
36876 PyThreadState* __tstate = wxPyBeginAllowThreads();
36877 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36878 wxPyEndAllowThreads(__tstate);
36879 if (PyErr_Occurred()) SWIG_fail;
36880 }
36881 {
36882 #if wxUSE_UNICODE
36883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36884 #else
36885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36886 #endif
36887 }
36888 return resultobj;
36889 fail:
36890 return NULL;
36891 }
36892
36893
36894 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36895 PyObject *resultobj = 0;
36896 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36897 wxString result;
36898 void *argp1 = 0 ;
36899 int res1 = 0 ;
36900 PyObject *swig_obj[1] ;
36901
36902 if (!args) SWIG_fail;
36903 swig_obj[0] = args;
36904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36905 if (!SWIG_IsOK(res1)) {
36906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36907 }
36908 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36912 wxPyEndAllowThreads(__tstate);
36913 if (PyErr_Occurred()) SWIG_fail;
36914 }
36915 {
36916 #if wxUSE_UNICODE
36917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36918 #else
36919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36920 #endif
36921 }
36922 return resultobj;
36923 fail:
36924 return NULL;
36925 }
36926
36927
36928 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36929 PyObject *resultobj = 0;
36930 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36931 wxString result;
36932 void *argp1 = 0 ;
36933 int res1 = 0 ;
36934 PyObject *swig_obj[1] ;
36935
36936 if (!args) SWIG_fail;
36937 swig_obj[0] = args;
36938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36939 if (!SWIG_IsOK(res1)) {
36940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36941 }
36942 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36943 {
36944 PyThreadState* __tstate = wxPyBeginAllowThreads();
36945 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
36946 wxPyEndAllowThreads(__tstate);
36947 if (PyErr_Occurred()) SWIG_fail;
36948 }
36949 {
36950 #if wxUSE_UNICODE
36951 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36952 #else
36953 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36954 #endif
36955 }
36956 return resultobj;
36957 fail:
36958 return NULL;
36959 }
36960
36961
36962 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36963 PyObject *resultobj = 0;
36964 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36965 wxString result;
36966 void *argp1 = 0 ;
36967 int res1 = 0 ;
36968 PyObject *swig_obj[1] ;
36969
36970 if (!args) SWIG_fail;
36971 swig_obj[0] = args;
36972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36973 if (!SWIG_IsOK(res1)) {
36974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36975 }
36976 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36977 {
36978 PyThreadState* __tstate = wxPyBeginAllowThreads();
36979 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
36980 wxPyEndAllowThreads(__tstate);
36981 if (PyErr_Occurred()) SWIG_fail;
36982 }
36983 {
36984 #if wxUSE_UNICODE
36985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36986 #else
36987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36988 #endif
36989 }
36990 return resultobj;
36991 fail:
36992 return NULL;
36993 }
36994
36995
36996 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36997 PyObject *resultobj = 0;
36998 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36999 wxString result;
37000 void *argp1 = 0 ;
37001 int res1 = 0 ;
37002 PyObject *swig_obj[1] ;
37003
37004 if (!args) SWIG_fail;
37005 swig_obj[0] = args;
37006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37007 if (!SWIG_IsOK(res1)) {
37008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37009 }
37010 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37011 {
37012 PyThreadState* __tstate = wxPyBeginAllowThreads();
37013 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37014 wxPyEndAllowThreads(__tstate);
37015 if (PyErr_Occurred()) SWIG_fail;
37016 }
37017 {
37018 #if wxUSE_UNICODE
37019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37020 #else
37021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37022 #endif
37023 }
37024 return resultobj;
37025 fail:
37026 return NULL;
37027 }
37028
37029
37030 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37031 PyObject *resultobj = 0;
37032 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37033 wxString *arg2 = 0 ;
37034 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37035 wxString result;
37036 void *argp1 = 0 ;
37037 int res1 = 0 ;
37038 bool temp2 = false ;
37039 int val3 ;
37040 int ecode3 = 0 ;
37041 PyObject * obj0 = 0 ;
37042 PyObject * obj1 = 0 ;
37043 PyObject * obj2 = 0 ;
37044 char * kwnames[] = {
37045 (char *) "self",(char *) "lang",(char *) "category", NULL
37046 };
37047
37048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37050 if (!SWIG_IsOK(res1)) {
37051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37052 }
37053 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37054 {
37055 arg2 = wxString_in_helper(obj1);
37056 if (arg2 == NULL) SWIG_fail;
37057 temp2 = true;
37058 }
37059 if (obj2) {
37060 ecode3 = SWIG_AsVal_int(obj2, &val3);
37061 if (!SWIG_IsOK(ecode3)) {
37062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37063 }
37064 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37065 }
37066 {
37067 PyThreadState* __tstate = wxPyBeginAllowThreads();
37068 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37069 wxPyEndAllowThreads(__tstate);
37070 if (PyErr_Occurred()) SWIG_fail;
37071 }
37072 {
37073 #if wxUSE_UNICODE
37074 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37075 #else
37076 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37077 #endif
37078 }
37079 {
37080 if (temp2)
37081 delete arg2;
37082 }
37083 return resultobj;
37084 fail:
37085 {
37086 if (temp2)
37087 delete arg2;
37088 }
37089 return NULL;
37090 }
37091
37092
37093 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37094 PyObject *resultobj = 0;
37095 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37096 wxString result;
37097 void *argp1 = 0 ;
37098 int res1 = 0 ;
37099 PyObject *swig_obj[1] ;
37100
37101 if (!args) SWIG_fail;
37102 swig_obj[0] = args;
37103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37104 if (!SWIG_IsOK(res1)) {
37105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37106 }
37107 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37108 {
37109 PyThreadState* __tstate = wxPyBeginAllowThreads();
37110 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37111 wxPyEndAllowThreads(__tstate);
37112 if (PyErr_Occurred()) SWIG_fail;
37113 }
37114 {
37115 #if wxUSE_UNICODE
37116 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37117 #else
37118 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37119 #endif
37120 }
37121 return resultobj;
37122 fail:
37123 return NULL;
37124 }
37125
37126
37127 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37128 PyObject *resultobj = 0;
37129 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37130 wxString *arg2 = 0 ;
37131 void *argp1 = 0 ;
37132 int res1 = 0 ;
37133 bool temp2 = false ;
37134 PyObject * obj0 = 0 ;
37135 PyObject * obj1 = 0 ;
37136 char * kwnames[] = {
37137 (char *) "self",(char *) "prefix", NULL
37138 };
37139
37140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37142 if (!SWIG_IsOK(res1)) {
37143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37144 }
37145 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37146 {
37147 arg2 = wxString_in_helper(obj1);
37148 if (arg2 == NULL) SWIG_fail;
37149 temp2 = true;
37150 }
37151 {
37152 PyThreadState* __tstate = wxPyBeginAllowThreads();
37153 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37154 wxPyEndAllowThreads(__tstate);
37155 if (PyErr_Occurred()) SWIG_fail;
37156 }
37157 resultobj = SWIG_Py_Void();
37158 {
37159 if (temp2)
37160 delete arg2;
37161 }
37162 return resultobj;
37163 fail:
37164 {
37165 if (temp2)
37166 delete arg2;
37167 }
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37173 PyObject *resultobj = 0;
37174 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37175 wxString result;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 PyObject *swig_obj[1] ;
37179
37180 if (!args) SWIG_fail;
37181 swig_obj[0] = args;
37182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37183 if (!SWIG_IsOK(res1)) {
37184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37185 }
37186 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 {
37194 #if wxUSE_UNICODE
37195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37196 #else
37197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37198 #endif
37199 }
37200 return resultobj;
37201 fail:
37202 return NULL;
37203 }
37204
37205
37206 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37207 PyObject *obj;
37208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37209 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37210 return SWIG_Py_Void();
37211 }
37212
37213 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37214 PyObject *resultobj = 0;
37215 wxEventType arg1 ;
37216 wxPowerEvent *result = 0 ;
37217 int val1 ;
37218 int ecode1 = 0 ;
37219 PyObject * obj0 = 0 ;
37220 char * kwnames[] = {
37221 (char *) "evtType", NULL
37222 };
37223
37224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37225 ecode1 = SWIG_AsVal_int(obj0, &val1);
37226 if (!SWIG_IsOK(ecode1)) {
37227 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37228 }
37229 arg1 = static_cast< wxEventType >(val1);
37230 {
37231 PyThreadState* __tstate = wxPyBeginAllowThreads();
37232 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37233 wxPyEndAllowThreads(__tstate);
37234 if (PyErr_Occurred()) SWIG_fail;
37235 }
37236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37237 return resultobj;
37238 fail:
37239 return NULL;
37240 }
37241
37242
37243 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37244 PyObject *resultobj = 0;
37245 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37246 void *argp1 = 0 ;
37247 int res1 = 0 ;
37248 PyObject *swig_obj[1] ;
37249
37250 if (!args) SWIG_fail;
37251 swig_obj[0] = args;
37252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37253 if (!SWIG_IsOK(res1)) {
37254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37255 }
37256 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37257 {
37258 PyThreadState* __tstate = wxPyBeginAllowThreads();
37259 (arg1)->Veto();
37260 wxPyEndAllowThreads(__tstate);
37261 if (PyErr_Occurred()) SWIG_fail;
37262 }
37263 resultobj = SWIG_Py_Void();
37264 return resultobj;
37265 fail:
37266 return NULL;
37267 }
37268
37269
37270 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37271 PyObject *resultobj = 0;
37272 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37273 bool result;
37274 void *argp1 = 0 ;
37275 int res1 = 0 ;
37276 PyObject *swig_obj[1] ;
37277
37278 if (!args) SWIG_fail;
37279 swig_obj[0] = args;
37280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37281 if (!SWIG_IsOK(res1)) {
37282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37283 }
37284 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37285 {
37286 PyThreadState* __tstate = wxPyBeginAllowThreads();
37287 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37288 wxPyEndAllowThreads(__tstate);
37289 if (PyErr_Occurred()) SWIG_fail;
37290 }
37291 {
37292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37293 }
37294 return resultobj;
37295 fail:
37296 return NULL;
37297 }
37298
37299
37300 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37301 PyObject *obj;
37302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37303 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37304 return SWIG_Py_Void();
37305 }
37306
37307 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37308 return SWIG_Python_InitShadowInstance(args);
37309 }
37310
37311 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37312 PyObject *resultobj = 0;
37313 wxPowerType result;
37314
37315 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37316 {
37317 PyThreadState* __tstate = wxPyBeginAllowThreads();
37318 result = (wxPowerType)wxGetPowerType();
37319 wxPyEndAllowThreads(__tstate);
37320 if (PyErr_Occurred()) SWIG_fail;
37321 }
37322 resultobj = SWIG_From_int(static_cast< int >(result));
37323 return resultobj;
37324 fail:
37325 return NULL;
37326 }
37327
37328
37329 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37330 PyObject *resultobj = 0;
37331 wxBatteryState result;
37332
37333 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37334 {
37335 PyThreadState* __tstate = wxPyBeginAllowThreads();
37336 result = (wxBatteryState)wxGetBatteryState();
37337 wxPyEndAllowThreads(__tstate);
37338 if (PyErr_Occurred()) SWIG_fail;
37339 }
37340 resultobj = SWIG_From_int(static_cast< int >(result));
37341 return resultobj;
37342 fail:
37343 return NULL;
37344 }
37345
37346
37347 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37348 PyObject *resultobj = 0;
37349 wxAboutDialogInfo *result = 0 ;
37350
37351 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37355 wxPyEndAllowThreads(__tstate);
37356 if (PyErr_Occurred()) SWIG_fail;
37357 }
37358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37359 return resultobj;
37360 fail:
37361 return NULL;
37362 }
37363
37364
37365 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37366 PyObject *resultobj = 0;
37367 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37368 void *argp1 = 0 ;
37369 int res1 = 0 ;
37370 PyObject *swig_obj[1] ;
37371
37372 if (!args) SWIG_fail;
37373 swig_obj[0] = args;
37374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37375 if (!SWIG_IsOK(res1)) {
37376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37377 }
37378 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37379 {
37380 PyThreadState* __tstate = wxPyBeginAllowThreads();
37381 delete arg1;
37382
37383 wxPyEndAllowThreads(__tstate);
37384 if (PyErr_Occurred()) SWIG_fail;
37385 }
37386 resultobj = SWIG_Py_Void();
37387 return resultobj;
37388 fail:
37389 return NULL;
37390 }
37391
37392
37393 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37394 PyObject *resultobj = 0;
37395 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37396 wxString *arg2 = 0 ;
37397 void *argp1 = 0 ;
37398 int res1 = 0 ;
37399 bool temp2 = false ;
37400 PyObject * obj0 = 0 ;
37401 PyObject * obj1 = 0 ;
37402 char * kwnames[] = {
37403 (char *) "self",(char *) "name", NULL
37404 };
37405
37406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37408 if (!SWIG_IsOK(res1)) {
37409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37410 }
37411 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37412 {
37413 arg2 = wxString_in_helper(obj1);
37414 if (arg2 == NULL) SWIG_fail;
37415 temp2 = true;
37416 }
37417 {
37418 PyThreadState* __tstate = wxPyBeginAllowThreads();
37419 (arg1)->SetName((wxString const &)*arg2);
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 resultobj = SWIG_Py_Void();
37424 {
37425 if (temp2)
37426 delete arg2;
37427 }
37428 return resultobj;
37429 fail:
37430 {
37431 if (temp2)
37432 delete arg2;
37433 }
37434 return NULL;
37435 }
37436
37437
37438 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37439 PyObject *resultobj = 0;
37440 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37441 wxString result;
37442 void *argp1 = 0 ;
37443 int res1 = 0 ;
37444 PyObject *swig_obj[1] ;
37445
37446 if (!args) SWIG_fail;
37447 swig_obj[0] = args;
37448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37449 if (!SWIG_IsOK(res1)) {
37450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37451 }
37452 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37453 {
37454 PyThreadState* __tstate = wxPyBeginAllowThreads();
37455 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37456 wxPyEndAllowThreads(__tstate);
37457 if (PyErr_Occurred()) SWIG_fail;
37458 }
37459 {
37460 #if wxUSE_UNICODE
37461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37462 #else
37463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37464 #endif
37465 }
37466 return resultobj;
37467 fail:
37468 return NULL;
37469 }
37470
37471
37472 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37473 PyObject *resultobj = 0;
37474 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37475 wxString *arg2 = 0 ;
37476 void *argp1 = 0 ;
37477 int res1 = 0 ;
37478 bool temp2 = false ;
37479 PyObject * obj0 = 0 ;
37480 PyObject * obj1 = 0 ;
37481 char * kwnames[] = {
37482 (char *) "self",(char *) "version", NULL
37483 };
37484
37485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37487 if (!SWIG_IsOK(res1)) {
37488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37489 }
37490 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37491 {
37492 arg2 = wxString_in_helper(obj1);
37493 if (arg2 == NULL) SWIG_fail;
37494 temp2 = true;
37495 }
37496 {
37497 PyThreadState* __tstate = wxPyBeginAllowThreads();
37498 (arg1)->SetVersion((wxString const &)*arg2);
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 resultobj = SWIG_Py_Void();
37503 {
37504 if (temp2)
37505 delete arg2;
37506 }
37507 return resultobj;
37508 fail:
37509 {
37510 if (temp2)
37511 delete arg2;
37512 }
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37518 PyObject *resultobj = 0;
37519 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37520 bool result;
37521 void *argp1 = 0 ;
37522 int res1 = 0 ;
37523 PyObject *swig_obj[1] ;
37524
37525 if (!args) SWIG_fail;
37526 swig_obj[0] = args;
37527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37528 if (!SWIG_IsOK(res1)) {
37529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37530 }
37531 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37532 {
37533 PyThreadState* __tstate = wxPyBeginAllowThreads();
37534 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37535 wxPyEndAllowThreads(__tstate);
37536 if (PyErr_Occurred()) SWIG_fail;
37537 }
37538 {
37539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37540 }
37541 return resultobj;
37542 fail:
37543 return NULL;
37544 }
37545
37546
37547 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37548 PyObject *resultobj = 0;
37549 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37550 wxString result;
37551 void *argp1 = 0 ;
37552 int res1 = 0 ;
37553 PyObject *swig_obj[1] ;
37554
37555 if (!args) SWIG_fail;
37556 swig_obj[0] = args;
37557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37558 if (!SWIG_IsOK(res1)) {
37559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37560 }
37561 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37562 {
37563 PyThreadState* __tstate = wxPyBeginAllowThreads();
37564 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37565 wxPyEndAllowThreads(__tstate);
37566 if (PyErr_Occurred()) SWIG_fail;
37567 }
37568 {
37569 #if wxUSE_UNICODE
37570 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37571 #else
37572 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37573 #endif
37574 }
37575 return resultobj;
37576 fail:
37577 return NULL;
37578 }
37579
37580
37581 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37582 PyObject *resultobj = 0;
37583 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37584 wxString *arg2 = 0 ;
37585 void *argp1 = 0 ;
37586 int res1 = 0 ;
37587 bool temp2 = false ;
37588 PyObject * obj0 = 0 ;
37589 PyObject * obj1 = 0 ;
37590 char * kwnames[] = {
37591 (char *) "self",(char *) "desc", NULL
37592 };
37593
37594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37596 if (!SWIG_IsOK(res1)) {
37597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37598 }
37599 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37600 {
37601 arg2 = wxString_in_helper(obj1);
37602 if (arg2 == NULL) SWIG_fail;
37603 temp2 = true;
37604 }
37605 {
37606 PyThreadState* __tstate = wxPyBeginAllowThreads();
37607 (arg1)->SetDescription((wxString const &)*arg2);
37608 wxPyEndAllowThreads(__tstate);
37609 if (PyErr_Occurred()) SWIG_fail;
37610 }
37611 resultobj = SWIG_Py_Void();
37612 {
37613 if (temp2)
37614 delete arg2;
37615 }
37616 return resultobj;
37617 fail:
37618 {
37619 if (temp2)
37620 delete arg2;
37621 }
37622 return NULL;
37623 }
37624
37625
37626 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37627 PyObject *resultobj = 0;
37628 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37629 bool result;
37630 void *argp1 = 0 ;
37631 int res1 = 0 ;
37632 PyObject *swig_obj[1] ;
37633
37634 if (!args) SWIG_fail;
37635 swig_obj[0] = args;
37636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37637 if (!SWIG_IsOK(res1)) {
37638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37639 }
37640 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37641 {
37642 PyThreadState* __tstate = wxPyBeginAllowThreads();
37643 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37644 wxPyEndAllowThreads(__tstate);
37645 if (PyErr_Occurred()) SWIG_fail;
37646 }
37647 {
37648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37649 }
37650 return resultobj;
37651 fail:
37652 return NULL;
37653 }
37654
37655
37656 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37657 PyObject *resultobj = 0;
37658 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37659 wxString result;
37660 void *argp1 = 0 ;
37661 int res1 = 0 ;
37662 PyObject *swig_obj[1] ;
37663
37664 if (!args) SWIG_fail;
37665 swig_obj[0] = args;
37666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37667 if (!SWIG_IsOK(res1)) {
37668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37669 }
37670 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37671 {
37672 PyThreadState* __tstate = wxPyBeginAllowThreads();
37673 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37674 wxPyEndAllowThreads(__tstate);
37675 if (PyErr_Occurred()) SWIG_fail;
37676 }
37677 {
37678 #if wxUSE_UNICODE
37679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37680 #else
37681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37682 #endif
37683 }
37684 return resultobj;
37685 fail:
37686 return NULL;
37687 }
37688
37689
37690 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37691 PyObject *resultobj = 0;
37692 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37693 wxString *arg2 = 0 ;
37694 void *argp1 = 0 ;
37695 int res1 = 0 ;
37696 bool temp2 = false ;
37697 PyObject * obj0 = 0 ;
37698 PyObject * obj1 = 0 ;
37699 char * kwnames[] = {
37700 (char *) "self",(char *) "copyright", NULL
37701 };
37702
37703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37705 if (!SWIG_IsOK(res1)) {
37706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37707 }
37708 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37709 {
37710 arg2 = wxString_in_helper(obj1);
37711 if (arg2 == NULL) SWIG_fail;
37712 temp2 = true;
37713 }
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 (arg1)->SetCopyright((wxString const &)*arg2);
37717 wxPyEndAllowThreads(__tstate);
37718 if (PyErr_Occurred()) SWIG_fail;
37719 }
37720 resultobj = SWIG_Py_Void();
37721 {
37722 if (temp2)
37723 delete arg2;
37724 }
37725 return resultobj;
37726 fail:
37727 {
37728 if (temp2)
37729 delete arg2;
37730 }
37731 return NULL;
37732 }
37733
37734
37735 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37736 PyObject *resultobj = 0;
37737 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37738 bool result;
37739 void *argp1 = 0 ;
37740 int res1 = 0 ;
37741 PyObject *swig_obj[1] ;
37742
37743 if (!args) SWIG_fail;
37744 swig_obj[0] = args;
37745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37746 if (!SWIG_IsOK(res1)) {
37747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37748 }
37749 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37750 {
37751 PyThreadState* __tstate = wxPyBeginAllowThreads();
37752 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37753 wxPyEndAllowThreads(__tstate);
37754 if (PyErr_Occurred()) SWIG_fail;
37755 }
37756 {
37757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37758 }
37759 return resultobj;
37760 fail:
37761 return NULL;
37762 }
37763
37764
37765 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37766 PyObject *resultobj = 0;
37767 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37768 wxString result;
37769 void *argp1 = 0 ;
37770 int res1 = 0 ;
37771 PyObject *swig_obj[1] ;
37772
37773 if (!args) SWIG_fail;
37774 swig_obj[0] = args;
37775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37776 if (!SWIG_IsOK(res1)) {
37777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37778 }
37779 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 {
37787 #if wxUSE_UNICODE
37788 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37789 #else
37790 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37791 #endif
37792 }
37793 return resultobj;
37794 fail:
37795 return NULL;
37796 }
37797
37798
37799 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37800 PyObject *resultobj = 0;
37801 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37802 wxString *arg2 = 0 ;
37803 void *argp1 = 0 ;
37804 int res1 = 0 ;
37805 bool temp2 = false ;
37806 PyObject * obj0 = 0 ;
37807 PyObject * obj1 = 0 ;
37808 char * kwnames[] = {
37809 (char *) "self",(char *) "licence", NULL
37810 };
37811
37812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37814 if (!SWIG_IsOK(res1)) {
37815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37816 }
37817 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37818 {
37819 arg2 = wxString_in_helper(obj1);
37820 if (arg2 == NULL) SWIG_fail;
37821 temp2 = true;
37822 }
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 (arg1)->SetLicence((wxString const &)*arg2);
37826 wxPyEndAllowThreads(__tstate);
37827 if (PyErr_Occurred()) SWIG_fail;
37828 }
37829 resultobj = SWIG_Py_Void();
37830 {
37831 if (temp2)
37832 delete arg2;
37833 }
37834 return resultobj;
37835 fail:
37836 {
37837 if (temp2)
37838 delete arg2;
37839 }
37840 return NULL;
37841 }
37842
37843
37844 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37845 PyObject *resultobj = 0;
37846 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37847 wxString *arg2 = 0 ;
37848 void *argp1 = 0 ;
37849 int res1 = 0 ;
37850 bool temp2 = false ;
37851 PyObject * obj0 = 0 ;
37852 PyObject * obj1 = 0 ;
37853 char * kwnames[] = {
37854 (char *) "self",(char *) "licence", NULL
37855 };
37856
37857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
37858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37859 if (!SWIG_IsOK(res1)) {
37860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37861 }
37862 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37863 {
37864 arg2 = wxString_in_helper(obj1);
37865 if (arg2 == NULL) SWIG_fail;
37866 temp2 = true;
37867 }
37868 {
37869 PyThreadState* __tstate = wxPyBeginAllowThreads();
37870 (arg1)->SetLicense((wxString const &)*arg2);
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 resultobj = SWIG_Py_Void();
37875 {
37876 if (temp2)
37877 delete arg2;
37878 }
37879 return resultobj;
37880 fail:
37881 {
37882 if (temp2)
37883 delete arg2;
37884 }
37885 return NULL;
37886 }
37887
37888
37889 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37890 PyObject *resultobj = 0;
37891 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37892 bool result;
37893 void *argp1 = 0 ;
37894 int res1 = 0 ;
37895 PyObject *swig_obj[1] ;
37896
37897 if (!args) SWIG_fail;
37898 swig_obj[0] = args;
37899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37900 if (!SWIG_IsOK(res1)) {
37901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37902 }
37903 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37904 {
37905 PyThreadState* __tstate = wxPyBeginAllowThreads();
37906 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
37907 wxPyEndAllowThreads(__tstate);
37908 if (PyErr_Occurred()) SWIG_fail;
37909 }
37910 {
37911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37912 }
37913 return resultobj;
37914 fail:
37915 return NULL;
37916 }
37917
37918
37919 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37920 PyObject *resultobj = 0;
37921 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37922 wxString result;
37923 void *argp1 = 0 ;
37924 int res1 = 0 ;
37925 PyObject *swig_obj[1] ;
37926
37927 if (!args) SWIG_fail;
37928 swig_obj[0] = args;
37929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37930 if (!SWIG_IsOK(res1)) {
37931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37932 }
37933 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37934 {
37935 PyThreadState* __tstate = wxPyBeginAllowThreads();
37936 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
37937 wxPyEndAllowThreads(__tstate);
37938 if (PyErr_Occurred()) SWIG_fail;
37939 }
37940 {
37941 #if wxUSE_UNICODE
37942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37943 #else
37944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37945 #endif
37946 }
37947 return resultobj;
37948 fail:
37949 return NULL;
37950 }
37951
37952
37953 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37954 PyObject *resultobj = 0;
37955 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37956 wxIcon *arg2 = 0 ;
37957 void *argp1 = 0 ;
37958 int res1 = 0 ;
37959 void *argp2 = 0 ;
37960 int res2 = 0 ;
37961 PyObject * obj0 = 0 ;
37962 PyObject * obj1 = 0 ;
37963 char * kwnames[] = {
37964 (char *) "self",(char *) "icon", NULL
37965 };
37966
37967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
37968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37969 if (!SWIG_IsOK(res1)) {
37970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37971 }
37972 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37973 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
37974 if (!SWIG_IsOK(res2)) {
37975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
37976 }
37977 if (!argp2) {
37978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
37979 }
37980 arg2 = reinterpret_cast< wxIcon * >(argp2);
37981 {
37982 PyThreadState* __tstate = wxPyBeginAllowThreads();
37983 (arg1)->SetIcon((wxIcon const &)*arg2);
37984 wxPyEndAllowThreads(__tstate);
37985 if (PyErr_Occurred()) SWIG_fail;
37986 }
37987 resultobj = SWIG_Py_Void();
37988 return resultobj;
37989 fail:
37990 return NULL;
37991 }
37992
37993
37994 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37995 PyObject *resultobj = 0;
37996 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37997 bool result;
37998 void *argp1 = 0 ;
37999 int res1 = 0 ;
38000 PyObject *swig_obj[1] ;
38001
38002 if (!args) SWIG_fail;
38003 swig_obj[0] = args;
38004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38005 if (!SWIG_IsOK(res1)) {
38006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38007 }
38008 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38009 {
38010 PyThreadState* __tstate = wxPyBeginAllowThreads();
38011 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38012 wxPyEndAllowThreads(__tstate);
38013 if (PyErr_Occurred()) SWIG_fail;
38014 }
38015 {
38016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38017 }
38018 return resultobj;
38019 fail:
38020 return NULL;
38021 }
38022
38023
38024 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38025 PyObject *resultobj = 0;
38026 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38027 wxIcon result;
38028 void *argp1 = 0 ;
38029 int res1 = 0 ;
38030 PyObject *swig_obj[1] ;
38031
38032 if (!args) SWIG_fail;
38033 swig_obj[0] = args;
38034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38035 if (!SWIG_IsOK(res1)) {
38036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38037 }
38038 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38039 {
38040 PyThreadState* __tstate = wxPyBeginAllowThreads();
38041 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38046 return resultobj;
38047 fail:
38048 return NULL;
38049 }
38050
38051
38052 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38053 PyObject *resultobj = 0;
38054 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38055 wxString *arg2 = 0 ;
38056 wxString const &arg3_defvalue = wxEmptyString ;
38057 wxString *arg3 = (wxString *) &arg3_defvalue ;
38058 void *argp1 = 0 ;
38059 int res1 = 0 ;
38060 bool temp2 = false ;
38061 bool temp3 = false ;
38062 PyObject * obj0 = 0 ;
38063 PyObject * obj1 = 0 ;
38064 PyObject * obj2 = 0 ;
38065 char * kwnames[] = {
38066 (char *) "self",(char *) "url",(char *) "desc", NULL
38067 };
38068
38069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38071 if (!SWIG_IsOK(res1)) {
38072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38073 }
38074 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38075 {
38076 arg2 = wxString_in_helper(obj1);
38077 if (arg2 == NULL) SWIG_fail;
38078 temp2 = true;
38079 }
38080 if (obj2) {
38081 {
38082 arg3 = wxString_in_helper(obj2);
38083 if (arg3 == NULL) SWIG_fail;
38084 temp3 = true;
38085 }
38086 }
38087 {
38088 PyThreadState* __tstate = wxPyBeginAllowThreads();
38089 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38090 wxPyEndAllowThreads(__tstate);
38091 if (PyErr_Occurred()) SWIG_fail;
38092 }
38093 resultobj = SWIG_Py_Void();
38094 {
38095 if (temp2)
38096 delete arg2;
38097 }
38098 {
38099 if (temp3)
38100 delete arg3;
38101 }
38102 return resultobj;
38103 fail:
38104 {
38105 if (temp2)
38106 delete arg2;
38107 }
38108 {
38109 if (temp3)
38110 delete arg3;
38111 }
38112 return NULL;
38113 }
38114
38115
38116 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38117 PyObject *resultobj = 0;
38118 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38119 wxString result;
38120 void *argp1 = 0 ;
38121 int res1 = 0 ;
38122 PyObject *swig_obj[1] ;
38123
38124 if (!args) SWIG_fail;
38125 swig_obj[0] = args;
38126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38127 if (!SWIG_IsOK(res1)) {
38128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38129 }
38130 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38131 {
38132 PyThreadState* __tstate = wxPyBeginAllowThreads();
38133 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 {
38138 #if wxUSE_UNICODE
38139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38140 #else
38141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38142 #endif
38143 }
38144 return resultobj;
38145 fail:
38146 return NULL;
38147 }
38148
38149
38150 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38151 PyObject *resultobj = 0;
38152 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38153 wxString result;
38154 void *argp1 = 0 ;
38155 int res1 = 0 ;
38156 PyObject *swig_obj[1] ;
38157
38158 if (!args) SWIG_fail;
38159 swig_obj[0] = args;
38160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38163 }
38164 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 {
38172 #if wxUSE_UNICODE
38173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38174 #else
38175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38176 #endif
38177 }
38178 return resultobj;
38179 fail:
38180 return NULL;
38181 }
38182
38183
38184 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38185 PyObject *resultobj = 0;
38186 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38187 bool result;
38188 void *argp1 = 0 ;
38189 int res1 = 0 ;
38190 PyObject *swig_obj[1] ;
38191
38192 if (!args) SWIG_fail;
38193 swig_obj[0] = args;
38194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38195 if (!SWIG_IsOK(res1)) {
38196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38197 }
38198 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38199 {
38200 PyThreadState* __tstate = wxPyBeginAllowThreads();
38201 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38202 wxPyEndAllowThreads(__tstate);
38203 if (PyErr_Occurred()) SWIG_fail;
38204 }
38205 {
38206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38207 }
38208 return resultobj;
38209 fail:
38210 return NULL;
38211 }
38212
38213
38214 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38215 PyObject *resultobj = 0;
38216 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38217 wxArrayString *arg2 = 0 ;
38218 void *argp1 = 0 ;
38219 int res1 = 0 ;
38220 bool temp2 = false ;
38221 PyObject * obj0 = 0 ;
38222 PyObject * obj1 = 0 ;
38223 char * kwnames[] = {
38224 (char *) "self",(char *) "developers", NULL
38225 };
38226
38227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38229 if (!SWIG_IsOK(res1)) {
38230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38231 }
38232 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38233 {
38234 if (! PySequence_Check(obj1)) {
38235 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38236 SWIG_fail;
38237 }
38238 arg2 = new wxArrayString;
38239 temp2 = true;
38240 int i, len=PySequence_Length(obj1);
38241 for (i=0; i<len; i++) {
38242 PyObject* item = PySequence_GetItem(obj1, i);
38243 wxString* s = wxString_in_helper(item);
38244 if (PyErr_Occurred()) SWIG_fail;
38245 arg2->Add(*s);
38246 delete s;
38247 Py_DECREF(item);
38248 }
38249 }
38250 {
38251 PyThreadState* __tstate = wxPyBeginAllowThreads();
38252 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38253 wxPyEndAllowThreads(__tstate);
38254 if (PyErr_Occurred()) SWIG_fail;
38255 }
38256 resultobj = SWIG_Py_Void();
38257 {
38258 if (temp2) delete arg2;
38259 }
38260 return resultobj;
38261 fail:
38262 {
38263 if (temp2) delete arg2;
38264 }
38265 return NULL;
38266 }
38267
38268
38269 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38270 PyObject *resultobj = 0;
38271 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38272 wxString *arg2 = 0 ;
38273 void *argp1 = 0 ;
38274 int res1 = 0 ;
38275 bool temp2 = false ;
38276 PyObject * obj0 = 0 ;
38277 PyObject * obj1 = 0 ;
38278 char * kwnames[] = {
38279 (char *) "self",(char *) "developer", NULL
38280 };
38281
38282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38284 if (!SWIG_IsOK(res1)) {
38285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38286 }
38287 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38288 {
38289 arg2 = wxString_in_helper(obj1);
38290 if (arg2 == NULL) SWIG_fail;
38291 temp2 = true;
38292 }
38293 {
38294 PyThreadState* __tstate = wxPyBeginAllowThreads();
38295 (arg1)->AddDeveloper((wxString const &)*arg2);
38296 wxPyEndAllowThreads(__tstate);
38297 if (PyErr_Occurred()) SWIG_fail;
38298 }
38299 resultobj = SWIG_Py_Void();
38300 {
38301 if (temp2)
38302 delete arg2;
38303 }
38304 return resultobj;
38305 fail:
38306 {
38307 if (temp2)
38308 delete arg2;
38309 }
38310 return NULL;
38311 }
38312
38313
38314 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38315 PyObject *resultobj = 0;
38316 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38317 bool result;
38318 void *argp1 = 0 ;
38319 int res1 = 0 ;
38320 PyObject *swig_obj[1] ;
38321
38322 if (!args) SWIG_fail;
38323 swig_obj[0] = args;
38324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38325 if (!SWIG_IsOK(res1)) {
38326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38327 }
38328 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38329 {
38330 PyThreadState* __tstate = wxPyBeginAllowThreads();
38331 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38332 wxPyEndAllowThreads(__tstate);
38333 if (PyErr_Occurred()) SWIG_fail;
38334 }
38335 {
38336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38337 }
38338 return resultobj;
38339 fail:
38340 return NULL;
38341 }
38342
38343
38344 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38345 PyObject *resultobj = 0;
38346 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38347 wxArrayString *result = 0 ;
38348 void *argp1 = 0 ;
38349 int res1 = 0 ;
38350 PyObject *swig_obj[1] ;
38351
38352 if (!args) SWIG_fail;
38353 swig_obj[0] = args;
38354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38355 if (!SWIG_IsOK(res1)) {
38356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38357 }
38358 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 {
38362 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38363 result = (wxArrayString *) &_result_ref;
38364 }
38365 wxPyEndAllowThreads(__tstate);
38366 if (PyErr_Occurred()) SWIG_fail;
38367 }
38368 {
38369 resultobj = wxArrayString2PyList_helper(*result);
38370 }
38371 return resultobj;
38372 fail:
38373 return NULL;
38374 }
38375
38376
38377 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38378 PyObject *resultobj = 0;
38379 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38380 wxArrayString *arg2 = 0 ;
38381 void *argp1 = 0 ;
38382 int res1 = 0 ;
38383 bool temp2 = false ;
38384 PyObject * obj0 = 0 ;
38385 PyObject * obj1 = 0 ;
38386 char * kwnames[] = {
38387 (char *) "self",(char *) "docwriters", NULL
38388 };
38389
38390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38392 if (!SWIG_IsOK(res1)) {
38393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38394 }
38395 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38396 {
38397 if (! PySequence_Check(obj1)) {
38398 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38399 SWIG_fail;
38400 }
38401 arg2 = new wxArrayString;
38402 temp2 = true;
38403 int i, len=PySequence_Length(obj1);
38404 for (i=0; i<len; i++) {
38405 PyObject* item = PySequence_GetItem(obj1, i);
38406 wxString* s = wxString_in_helper(item);
38407 if (PyErr_Occurred()) SWIG_fail;
38408 arg2->Add(*s);
38409 delete s;
38410 Py_DECREF(item);
38411 }
38412 }
38413 {
38414 PyThreadState* __tstate = wxPyBeginAllowThreads();
38415 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38416 wxPyEndAllowThreads(__tstate);
38417 if (PyErr_Occurred()) SWIG_fail;
38418 }
38419 resultobj = SWIG_Py_Void();
38420 {
38421 if (temp2) delete arg2;
38422 }
38423 return resultobj;
38424 fail:
38425 {
38426 if (temp2) delete arg2;
38427 }
38428 return NULL;
38429 }
38430
38431
38432 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38433 PyObject *resultobj = 0;
38434 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38435 wxString *arg2 = 0 ;
38436 void *argp1 = 0 ;
38437 int res1 = 0 ;
38438 bool temp2 = false ;
38439 PyObject * obj0 = 0 ;
38440 PyObject * obj1 = 0 ;
38441 char * kwnames[] = {
38442 (char *) "self",(char *) "docwriter", NULL
38443 };
38444
38445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38447 if (!SWIG_IsOK(res1)) {
38448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38449 }
38450 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38451 {
38452 arg2 = wxString_in_helper(obj1);
38453 if (arg2 == NULL) SWIG_fail;
38454 temp2 = true;
38455 }
38456 {
38457 PyThreadState* __tstate = wxPyBeginAllowThreads();
38458 (arg1)->AddDocWriter((wxString const &)*arg2);
38459 wxPyEndAllowThreads(__tstate);
38460 if (PyErr_Occurred()) SWIG_fail;
38461 }
38462 resultobj = SWIG_Py_Void();
38463 {
38464 if (temp2)
38465 delete arg2;
38466 }
38467 return resultobj;
38468 fail:
38469 {
38470 if (temp2)
38471 delete arg2;
38472 }
38473 return NULL;
38474 }
38475
38476
38477 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38478 PyObject *resultobj = 0;
38479 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38480 bool result;
38481 void *argp1 = 0 ;
38482 int res1 = 0 ;
38483 PyObject *swig_obj[1] ;
38484
38485 if (!args) SWIG_fail;
38486 swig_obj[0] = args;
38487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38488 if (!SWIG_IsOK(res1)) {
38489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38490 }
38491 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38492 {
38493 PyThreadState* __tstate = wxPyBeginAllowThreads();
38494 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38495 wxPyEndAllowThreads(__tstate);
38496 if (PyErr_Occurred()) SWIG_fail;
38497 }
38498 {
38499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38500 }
38501 return resultobj;
38502 fail:
38503 return NULL;
38504 }
38505
38506
38507 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38508 PyObject *resultobj = 0;
38509 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38510 wxArrayString *result = 0 ;
38511 void *argp1 = 0 ;
38512 int res1 = 0 ;
38513 PyObject *swig_obj[1] ;
38514
38515 if (!args) SWIG_fail;
38516 swig_obj[0] = args;
38517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38518 if (!SWIG_IsOK(res1)) {
38519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38520 }
38521 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38522 {
38523 PyThreadState* __tstate = wxPyBeginAllowThreads();
38524 {
38525 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38526 result = (wxArrayString *) &_result_ref;
38527 }
38528 wxPyEndAllowThreads(__tstate);
38529 if (PyErr_Occurred()) SWIG_fail;
38530 }
38531 {
38532 resultobj = wxArrayString2PyList_helper(*result);
38533 }
38534 return resultobj;
38535 fail:
38536 return NULL;
38537 }
38538
38539
38540 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38541 PyObject *resultobj = 0;
38542 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38543 wxArrayString *arg2 = 0 ;
38544 void *argp1 = 0 ;
38545 int res1 = 0 ;
38546 bool temp2 = false ;
38547 PyObject * obj0 = 0 ;
38548 PyObject * obj1 = 0 ;
38549 char * kwnames[] = {
38550 (char *) "self",(char *) "artists", NULL
38551 };
38552
38553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38555 if (!SWIG_IsOK(res1)) {
38556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38557 }
38558 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38559 {
38560 if (! PySequence_Check(obj1)) {
38561 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38562 SWIG_fail;
38563 }
38564 arg2 = new wxArrayString;
38565 temp2 = true;
38566 int i, len=PySequence_Length(obj1);
38567 for (i=0; i<len; i++) {
38568 PyObject* item = PySequence_GetItem(obj1, i);
38569 wxString* s = wxString_in_helper(item);
38570 if (PyErr_Occurred()) SWIG_fail;
38571 arg2->Add(*s);
38572 delete s;
38573 Py_DECREF(item);
38574 }
38575 }
38576 {
38577 PyThreadState* __tstate = wxPyBeginAllowThreads();
38578 (arg1)->SetArtists((wxArrayString const &)*arg2);
38579 wxPyEndAllowThreads(__tstate);
38580 if (PyErr_Occurred()) SWIG_fail;
38581 }
38582 resultobj = SWIG_Py_Void();
38583 {
38584 if (temp2) delete arg2;
38585 }
38586 return resultobj;
38587 fail:
38588 {
38589 if (temp2) delete arg2;
38590 }
38591 return NULL;
38592 }
38593
38594
38595 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38596 PyObject *resultobj = 0;
38597 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38598 wxString *arg2 = 0 ;
38599 void *argp1 = 0 ;
38600 int res1 = 0 ;
38601 bool temp2 = false ;
38602 PyObject * obj0 = 0 ;
38603 PyObject * obj1 = 0 ;
38604 char * kwnames[] = {
38605 (char *) "self",(char *) "artist", NULL
38606 };
38607
38608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38610 if (!SWIG_IsOK(res1)) {
38611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38612 }
38613 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38614 {
38615 arg2 = wxString_in_helper(obj1);
38616 if (arg2 == NULL) SWIG_fail;
38617 temp2 = true;
38618 }
38619 {
38620 PyThreadState* __tstate = wxPyBeginAllowThreads();
38621 (arg1)->AddArtist((wxString const &)*arg2);
38622 wxPyEndAllowThreads(__tstate);
38623 if (PyErr_Occurred()) SWIG_fail;
38624 }
38625 resultobj = SWIG_Py_Void();
38626 {
38627 if (temp2)
38628 delete arg2;
38629 }
38630 return resultobj;
38631 fail:
38632 {
38633 if (temp2)
38634 delete arg2;
38635 }
38636 return NULL;
38637 }
38638
38639
38640 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38641 PyObject *resultobj = 0;
38642 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38643 bool result;
38644 void *argp1 = 0 ;
38645 int res1 = 0 ;
38646 PyObject *swig_obj[1] ;
38647
38648 if (!args) SWIG_fail;
38649 swig_obj[0] = args;
38650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38651 if (!SWIG_IsOK(res1)) {
38652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38653 }
38654 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38655 {
38656 PyThreadState* __tstate = wxPyBeginAllowThreads();
38657 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38658 wxPyEndAllowThreads(__tstate);
38659 if (PyErr_Occurred()) SWIG_fail;
38660 }
38661 {
38662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38663 }
38664 return resultobj;
38665 fail:
38666 return NULL;
38667 }
38668
38669
38670 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38671 PyObject *resultobj = 0;
38672 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38673 wxArrayString *result = 0 ;
38674 void *argp1 = 0 ;
38675 int res1 = 0 ;
38676 PyObject *swig_obj[1] ;
38677
38678 if (!args) SWIG_fail;
38679 swig_obj[0] = args;
38680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38681 if (!SWIG_IsOK(res1)) {
38682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38683 }
38684 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38685 {
38686 PyThreadState* __tstate = wxPyBeginAllowThreads();
38687 {
38688 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38689 result = (wxArrayString *) &_result_ref;
38690 }
38691 wxPyEndAllowThreads(__tstate);
38692 if (PyErr_Occurred()) SWIG_fail;
38693 }
38694 {
38695 resultobj = wxArrayString2PyList_helper(*result);
38696 }
38697 return resultobj;
38698 fail:
38699 return NULL;
38700 }
38701
38702
38703 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38704 PyObject *resultobj = 0;
38705 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38706 wxArrayString *arg2 = 0 ;
38707 void *argp1 = 0 ;
38708 int res1 = 0 ;
38709 bool temp2 = false ;
38710 PyObject * obj0 = 0 ;
38711 PyObject * obj1 = 0 ;
38712 char * kwnames[] = {
38713 (char *) "self",(char *) "translators", NULL
38714 };
38715
38716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38718 if (!SWIG_IsOK(res1)) {
38719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38720 }
38721 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38722 {
38723 if (! PySequence_Check(obj1)) {
38724 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38725 SWIG_fail;
38726 }
38727 arg2 = new wxArrayString;
38728 temp2 = true;
38729 int i, len=PySequence_Length(obj1);
38730 for (i=0; i<len; i++) {
38731 PyObject* item = PySequence_GetItem(obj1, i);
38732 wxString* s = wxString_in_helper(item);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 arg2->Add(*s);
38735 delete s;
38736 Py_DECREF(item);
38737 }
38738 }
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 resultobj = SWIG_Py_Void();
38746 {
38747 if (temp2) delete arg2;
38748 }
38749 return resultobj;
38750 fail:
38751 {
38752 if (temp2) delete arg2;
38753 }
38754 return NULL;
38755 }
38756
38757
38758 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38759 PyObject *resultobj = 0;
38760 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38761 wxString *arg2 = 0 ;
38762 void *argp1 = 0 ;
38763 int res1 = 0 ;
38764 bool temp2 = false ;
38765 PyObject * obj0 = 0 ;
38766 PyObject * obj1 = 0 ;
38767 char * kwnames[] = {
38768 (char *) "self",(char *) "translator", NULL
38769 };
38770
38771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38773 if (!SWIG_IsOK(res1)) {
38774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38775 }
38776 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38777 {
38778 arg2 = wxString_in_helper(obj1);
38779 if (arg2 == NULL) SWIG_fail;
38780 temp2 = true;
38781 }
38782 {
38783 PyThreadState* __tstate = wxPyBeginAllowThreads();
38784 (arg1)->AddTranslator((wxString const &)*arg2);
38785 wxPyEndAllowThreads(__tstate);
38786 if (PyErr_Occurred()) SWIG_fail;
38787 }
38788 resultobj = SWIG_Py_Void();
38789 {
38790 if (temp2)
38791 delete arg2;
38792 }
38793 return resultobj;
38794 fail:
38795 {
38796 if (temp2)
38797 delete arg2;
38798 }
38799 return NULL;
38800 }
38801
38802
38803 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38804 PyObject *resultobj = 0;
38805 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38806 bool result;
38807 void *argp1 = 0 ;
38808 int res1 = 0 ;
38809 PyObject *swig_obj[1] ;
38810
38811 if (!args) SWIG_fail;
38812 swig_obj[0] = args;
38813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38814 if (!SWIG_IsOK(res1)) {
38815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38816 }
38817 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38818 {
38819 PyThreadState* __tstate = wxPyBeginAllowThreads();
38820 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38821 wxPyEndAllowThreads(__tstate);
38822 if (PyErr_Occurred()) SWIG_fail;
38823 }
38824 {
38825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38826 }
38827 return resultobj;
38828 fail:
38829 return NULL;
38830 }
38831
38832
38833 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38834 PyObject *resultobj = 0;
38835 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38836 wxArrayString *result = 0 ;
38837 void *argp1 = 0 ;
38838 int res1 = 0 ;
38839 PyObject *swig_obj[1] ;
38840
38841 if (!args) SWIG_fail;
38842 swig_obj[0] = args;
38843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38844 if (!SWIG_IsOK(res1)) {
38845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38846 }
38847 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38848 {
38849 PyThreadState* __tstate = wxPyBeginAllowThreads();
38850 {
38851 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
38852 result = (wxArrayString *) &_result_ref;
38853 }
38854 wxPyEndAllowThreads(__tstate);
38855 if (PyErr_Occurred()) SWIG_fail;
38856 }
38857 {
38858 resultobj = wxArrayString2PyList_helper(*result);
38859 }
38860 return resultobj;
38861 fail:
38862 return NULL;
38863 }
38864
38865
38866 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38867 PyObject *resultobj = 0;
38868 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38869 bool result;
38870 void *argp1 = 0 ;
38871 int res1 = 0 ;
38872 PyObject *swig_obj[1] ;
38873
38874 if (!args) SWIG_fail;
38875 swig_obj[0] = args;
38876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38877 if (!SWIG_IsOK(res1)) {
38878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38879 }
38880 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38881 {
38882 PyThreadState* __tstate = wxPyBeginAllowThreads();
38883 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
38884 wxPyEndAllowThreads(__tstate);
38885 if (PyErr_Occurred()) SWIG_fail;
38886 }
38887 {
38888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38889 }
38890 return resultobj;
38891 fail:
38892 return NULL;
38893 }
38894
38895
38896 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38897 PyObject *resultobj = 0;
38898 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38899 wxString result;
38900 void *argp1 = 0 ;
38901 int res1 = 0 ;
38902 PyObject *swig_obj[1] ;
38903
38904 if (!args) SWIG_fail;
38905 swig_obj[0] = args;
38906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38907 if (!SWIG_IsOK(res1)) {
38908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38909 }
38910 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38911 {
38912 PyThreadState* __tstate = wxPyBeginAllowThreads();
38913 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
38914 wxPyEndAllowThreads(__tstate);
38915 if (PyErr_Occurred()) SWIG_fail;
38916 }
38917 {
38918 #if wxUSE_UNICODE
38919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38920 #else
38921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38922 #endif
38923 }
38924 return resultobj;
38925 fail:
38926 return NULL;
38927 }
38928
38929
38930 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38931 PyObject *obj;
38932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38933 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
38934 return SWIG_Py_Void();
38935 }
38936
38937 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38938 return SWIG_Python_InitShadowInstance(args);
38939 }
38940
38941 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38942 PyObject *resultobj = 0;
38943 wxAboutDialogInfo *arg1 = 0 ;
38944 void *argp1 = 0 ;
38945 int res1 = 0 ;
38946 PyObject * obj0 = 0 ;
38947 char * kwnames[] = {
38948 (char *) "info", NULL
38949 };
38950
38951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
38952 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
38953 if (!SWIG_IsOK(res1)) {
38954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
38955 }
38956 if (!argp1) {
38957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
38958 }
38959 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38960 {
38961 PyThreadState* __tstate = wxPyBeginAllowThreads();
38962 wxAboutBox((wxAboutDialogInfo const &)*arg1);
38963 wxPyEndAllowThreads(__tstate);
38964 if (PyErr_Occurred()) SWIG_fail;
38965 }
38966 resultobj = SWIG_Py_Void();
38967 return resultobj;
38968 fail:
38969 return NULL;
38970 }
38971
38972
38973 static PyMethodDef SwigMethods[] = {
38974 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
38975 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
38976 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
38977 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
38978 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
38979 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
38980 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
38981 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
38982 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
38983 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
38984 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
38985 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
38986 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
38987 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
38988 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
38989 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
38990 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
38991 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
38992 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
38993 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
38994 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
38995 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
38996 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
38997 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
38998 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
38999 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39000 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39001 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39002 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39003 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39004 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39005 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39006 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39007 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39008 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39009 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39010 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39011 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39012 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39013 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39014 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39015 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39016 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39017 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39018 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39019 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39020 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39021 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39022 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39023 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39024 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39025 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39026 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39027 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39028 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39029 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39030 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39031 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39032 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39033 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39034 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39035 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39036 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39037 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39038 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39039 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39040 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39041 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39042 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39043 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39044 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39045 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39046 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39047 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39048 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39049 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39050 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39051 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39052 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39053 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39054 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39055 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39056 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39057 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39058 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39059 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39060 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39061 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39062 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39063 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39064 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39065 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39066 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39067 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39068 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39069 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39070 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39071 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39072 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39073 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39074 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39075 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39076 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39077 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39078 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39079 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39080 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39081 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39082 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39083 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39084 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39085 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39086 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39087 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39088 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39089 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39090 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39091 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39092 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39093 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39094 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39095 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39096 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39097 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39098 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39099 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39100 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39101 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39102 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39103 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39104 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39105 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39106 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39107 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39108 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39109 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39110 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39111 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39112 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39113 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39114 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39115 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39116 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39117 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39118 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39119 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39120 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39121 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39122 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39123 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39124 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39125 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39126 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39127 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39128 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39129 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39130 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39131 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39132 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39133 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39134 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39135 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39136 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39137 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39138 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39139 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39140 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39141 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39142 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39143 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39144 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39145 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39146 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39147 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39148 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39149 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39151 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39152 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39153 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39154 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39155 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39156 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39157 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39158 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39159 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39160 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39161 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39162 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39163 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39164 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39165 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39166 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39167 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39168 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39169 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39170 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39171 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39172 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39173 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39174 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39175 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39176 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39178 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39179 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39180 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39181 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39182 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39183 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39184 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39185 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39186 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39187 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39188 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39189 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39191 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39194 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39195 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39196 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39197 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39198 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39199 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39200 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39201 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39202 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39203 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39204 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39205 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39206 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39207 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39208 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39209 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39210 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39211 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39213 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39214 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39215 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39216 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39217 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39218 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39219 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39220 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39221 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39222 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39223 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39224 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39225 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39226 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39227 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39228 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39230 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39231 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39232 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39234 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39236 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39238 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39239 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39240 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39241 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39242 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39243 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39244 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39245 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39246 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39247 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39248 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39249 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39250 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39251 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39252 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39253 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39254 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39256 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39257 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39258 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39259 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39260 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39263 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39264 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39265 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39267 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39268 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39271 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39272 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39273 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39274 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39275 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39276 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39277 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39278 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39279 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39280 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39281 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39282 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39283 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39284 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39285 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39291 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39292 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39293 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39295 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39296 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39297 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39298 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39299 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39301 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39302 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39305 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39306 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39307 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39309 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39310 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39311 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39312 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39313 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39314 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39315 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39316 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39317 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39318 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39319 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39320 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39322 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39323 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39324 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39325 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39326 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39327 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39328 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39329 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39330 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39333 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39334 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39335 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39336 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39337 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39338 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39339 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39340 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39341 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39342 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39344 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39345 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39346 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39347 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39348 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39349 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39350 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39351 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39352 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39353 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39354 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39355 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39356 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39357 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39358 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39359 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39360 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39361 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39362 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39363 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39364 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39365 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39366 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39367 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39368 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39369 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39370 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39371 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39372 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39373 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39375 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39376 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39377 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39379 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39380 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39381 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39382 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39383 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39384 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39385 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39387 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39388 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39389 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39390 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39391 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39395 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39396 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39397 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39398 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39399 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39402 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39405 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39406 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39407 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39410 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39411 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39414 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39415 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39416 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39417 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39418 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39419 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39420 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39421 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39422 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39423 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39424 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39426 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39427 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39428 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39429 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39430 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39431 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39432 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39433 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39434 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39436 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39437 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39438 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39439 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39440 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39441 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39442 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39443 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39445 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39446 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39447 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39450 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39454 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39455 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39456 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39457 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39458 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39459 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39460 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39461 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39462 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39467 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39468 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39469 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39470 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39472 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39473 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39474 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39475 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39476 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39477 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39478 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39479 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39480 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39481 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39482 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39483 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39484 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39485 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39487 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39488 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39489 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39490 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39491 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39492 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39493 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39494 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39495 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39498 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39499 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39500 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39501 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39502 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39503 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39504 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39506 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39507 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39511 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39512 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39514 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39515 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39516 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39517 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39518 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39519 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39520 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39522 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39523 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39524 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39525 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39527 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39528 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39529 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39530 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39531 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39532 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39533 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39534 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39537 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39538 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39539 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39540 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39541 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39542 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39543 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39544 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39545 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39546 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39548 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39551 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39552 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39553 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39554 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39555 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39558 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39559 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39560 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39561 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39562 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39563 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39564 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39565 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39566 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39572 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39575 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39576 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39577 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39578 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39579 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39580 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39581 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39582 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39583 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39584 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39585 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39586 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39589 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39590 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39591 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39594 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39595 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39598 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39599 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39600 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39601 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39603 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39606 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39625 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39626 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39627 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39628 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39632 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39633 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39634 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39636 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39638 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39641 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39642 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39643 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39644 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39645 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39646 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39648 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39650 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39652 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39654 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39656 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39658 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39660 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39664 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39665 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39669 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39680 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39681 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39682 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39686 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39687 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39688 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39689 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39690 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39691 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39693 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39694 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39696 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39698 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39700 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39702 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39704 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39709 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39710 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39711 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39712 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39713 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39716 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39720 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39728 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39729 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39730 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39731 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39732 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39733 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39736 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39737 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39738 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39740 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39741 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39743 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39744 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39745 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39753 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39755 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39757 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39758 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39760 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39761 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39764 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39765 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39766 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39768 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39769 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39770 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39772 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39773 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39775 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39776 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39779 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39780 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39782 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39784 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39785 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39788 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39789 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39790 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39791 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39793 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39794 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39795 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39797 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39798 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39799 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39800 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39802 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39804 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39805 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39806 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39807 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39808 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39812 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39814 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39818 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39819 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39822 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39823 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
39827 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
39829 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
39831 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
39832 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
39833 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
39834 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
39839 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
39842 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
39843 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
39844 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
39849 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
39852 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
39853 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
39854 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
39855 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
39856 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
39857 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
39858 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
39863 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
39864 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
39865 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
39866 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
39867 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
39868 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
39870 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
39871 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
39872 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
39873 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
39875 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
39877 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
39878 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
39879 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
39880 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
39883 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
39884 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
39885 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
39886 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
39887 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
39888 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
39889 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
39890 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
39891 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
39892 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
39894 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
39895 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
39898 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
39899 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
39900 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
39901 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
39902 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
39904 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
39905 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
39906 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
39907 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
39908 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
39909 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
39910 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
39911 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
39912 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
39913 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
39914 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
39915 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
39916 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
39917 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
39919 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
39921 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
39922 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
39924 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
39925 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
39926 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
39927 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
39928 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
39929 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
39930 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
39931 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
39933 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
39935 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
39936 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
39938 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
39939 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
39941 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
39942 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
39945 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
39946 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
39948 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
39949 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
39951 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
39952 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
39953 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
39955 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
39956 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
39957 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
39960 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
39961 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
39964 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
39965 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
39968 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
39969 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
39970 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
39971 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
39972 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
39973 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { NULL, NULL, 0, NULL }
39975 };
39976
39977
39978 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
39979
39980 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
39981 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
39982 }
39983 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
39984 return (void *)((wxEvent *) ((wxMenuEvent *) x));
39985 }
39986 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
39987 return (void *)((wxEvent *) ((wxCloseEvent *) x));
39988 }
39989 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
39990 return (void *)((wxEvent *) ((wxMouseEvent *) x));
39991 }
39992 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
39993 return (void *)((wxEvent *) ((wxEraseEvent *) x));
39994 }
39995 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
39996 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
39997 }
39998 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
39999 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40000 }
40001 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40002 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40003 }
40004 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40005 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40006 }
40007 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40008 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40009 }
40010 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40011 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40012 }
40013 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40014 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40015 }
40016 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40017 return (void *)((wxEvent *) ((wxPyEvent *) x));
40018 }
40019 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40020 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40021 }
40022 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40023 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40024 }
40025 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40026 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40027 }
40028 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40029 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40030 }
40031 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40032 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40033 }
40034 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40035 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40036 }
40037 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40038 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40039 }
40040 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40041 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40042 }
40043 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40044 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40045 }
40046 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40047 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40048 }
40049 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40050 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40051 }
40052 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40053 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40054 }
40055 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40056 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40057 }
40058 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40059 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40060 }
40061 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40062 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40063 }
40064 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40065 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40066 }
40067 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40068 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40069 }
40070 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40071 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40072 }
40073 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40074 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40075 }
40076 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40077 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40078 }
40079 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40080 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40081 }
40082 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40083 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40084 }
40085 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40086 return (void *)((wxEvent *) ((wxShowEvent *) x));
40087 }
40088 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40089 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40090 }
40091 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40092 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40093 }
40094 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40095 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40096 }
40097 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40098 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40099 }
40100 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40101 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40102 }
40103 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40104 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40105 }
40106 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40107 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40108 }
40109 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40110 return (void *)((wxConfigBase *) ((wxConfig *) x));
40111 }
40112 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40113 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40114 }
40115 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40116 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40117 }
40118 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40119 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40120 }
40121 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40122 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40123 }
40124 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40125 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40126 }
40127 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40128 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40129 }
40130 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40131 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40132 }
40133 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40134 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40135 }
40136 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40137 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40138 }
40139 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40140 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40141 }
40142 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40143 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40144 }
40145 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40146 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40147 }
40148 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40149 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40150 }
40151 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40152 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40153 }
40154 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40155 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40156 }
40157 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40158 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40159 }
40160 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40161 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40162 }
40163 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40164 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40165 }
40166 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40167 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40168 }
40169 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40170 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40171 }
40172 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40173 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40174 }
40175 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40176 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40177 }
40178 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40179 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40180 }
40181 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40182 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40183 }
40184 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40185 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40186 }
40187 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40188 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40189 }
40190 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40191 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40192 }
40193 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40194 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40195 }
40196 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40197 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40198 }
40199 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40200 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40201 }
40202 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40203 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40204 }
40205 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40206 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40207 }
40208 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40209 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40210 }
40211 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40212 return (void *)((wxObject *) ((wxSizerItem *) x));
40213 }
40214 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40215 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40216 }
40217 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40218 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40219 }
40220 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40221 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40222 }
40223 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40224 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40225 }
40226 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40227 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40228 }
40229 static void *_p_wxSizerTo_p_wxObject(void *x) {
40230 return (void *)((wxObject *) ((wxSizer *) x));
40231 }
40232 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40233 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40234 }
40235 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40236 return (void *)((wxObject *) ((wxFileHistory *) x));
40237 }
40238 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40239 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40240 }
40241 static void *_p_wxEventTo_p_wxObject(void *x) {
40242 return (void *)((wxObject *) ((wxEvent *) x));
40243 }
40244 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40245 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40246 }
40247 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40248 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40249 }
40250 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40251 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40252 }
40253 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40254 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40255 }
40256 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40257 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40258 }
40259 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40260 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40261 }
40262 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40263 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40264 }
40265 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40266 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40267 }
40268 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40269 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40270 }
40271 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40272 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40273 }
40274 static void *_p_wxControlTo_p_wxObject(void *x) {
40275 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40276 }
40277 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40278 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40279 }
40280 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40281 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40282 }
40283 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40284 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40285 }
40286 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40287 return (void *)((wxObject *) ((wxFSFile *) x));
40288 }
40289 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40290 return (void *)((wxObject *) ((wxClipboard *) x));
40291 }
40292 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40293 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40294 }
40295 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40296 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40297 }
40298 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40299 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40300 }
40301 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40302 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40303 }
40304 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40305 return (void *)((wxObject *) ((wxToolTip *) x));
40306 }
40307 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40308 return (void *)((wxObject *) ((wxMenuItem *) x));
40309 }
40310 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40311 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40312 }
40313 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40314 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40315 }
40316 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40317 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40318 }
40319 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40320 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40321 }
40322 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40323 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40324 }
40325 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40326 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40327 }
40328 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40329 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40330 }
40331 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40332 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40333 }
40334 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40335 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40336 }
40337 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40338 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40339 }
40340 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40341 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40342 }
40343 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40344 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40345 }
40346 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40347 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40348 }
40349 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40350 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40351 }
40352 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40353 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40354 }
40355 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40356 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40357 }
40358 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40359 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40360 }
40361 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40362 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40363 }
40364 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40365 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40366 }
40367 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40368 return (void *)((wxObject *) ((wxImageHandler *) x));
40369 }
40370 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40371 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40372 }
40373 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40374 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40375 }
40376 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40377 return (void *)((wxObject *) ((wxEvtHandler *) x));
40378 }
40379 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40380 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40381 }
40382 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40383 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40384 }
40385 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40386 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40387 }
40388 static void *_p_wxImageTo_p_wxObject(void *x) {
40389 return (void *)((wxObject *) ((wxImage *) x));
40390 }
40391 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40392 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40393 }
40394 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40395 return (void *)((wxObject *) ((wxSystemOptions *) x));
40396 }
40397 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40398 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40399 }
40400 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40401 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40402 }
40403 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40404 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40405 }
40406 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40407 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40408 }
40409 static void *_p_wxWindowTo_p_wxObject(void *x) {
40410 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40411 }
40412 static void *_p_wxMenuTo_p_wxObject(void *x) {
40413 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40414 }
40415 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40416 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40417 }
40418 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40419 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40420 }
40421 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40422 return (void *)((wxObject *) ((wxFileSystem *) x));
40423 }
40424 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40425 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40426 }
40427 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40428 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40429 }
40430 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40431 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40432 }
40433 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40434 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40435 }
40436 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40437 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40438 }
40439 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40440 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40441 }
40442 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40443 return (void *)((wxObject *) ((wxBusyInfo *) x));
40444 }
40445 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40446 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40447 }
40448 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40449 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40450 }
40451 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40452 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40453 }
40454 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40455 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40456 }
40457 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40458 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40459 }
40460 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40461 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40462 }
40463 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40464 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40465 }
40466 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40467 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40468 }
40469 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40470 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40471 }
40472 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40473 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40474 }
40475 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40476 return (void *)((wxLog *) ((wxLogBuffer *) x));
40477 }
40478 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40479 return (void *)((wxLog *) ((wxLogStderr *) x));
40480 }
40481 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40482 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40483 }
40484 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40485 return (void *)((wxLog *) ((wxLogWindow *) x));
40486 }
40487 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40488 return (void *)((wxLog *) ((wxLogChain *) x));
40489 }
40490 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40491 return (void *)((wxLog *) ((wxLogGui *) x));
40492 }
40493 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40494 return (void *)((wxLog *) ((wxPyLog *) x));
40495 }
40496 static void *_p_wxControlTo_p_wxWindow(void *x) {
40497 return (void *)((wxWindow *) ((wxControl *) x));
40498 }
40499 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40500 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40501 }
40502 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40503 return (void *)((wxWindow *) ((wxMenuBar *) x));
40504 }
40505 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40506 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40507 }
40508 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40509 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40510 }
40511 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40512 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};
40513 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40514 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40515 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40516 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40517 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40518 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40519 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40520 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40521 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40522 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40523 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40524 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40525 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40526 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40527 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40528 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40529 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40530 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40531 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40532 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40533 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40534 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40535 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40536 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40537 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40538 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40539 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40540 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40541 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40542 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40543 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40544 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40545 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40546 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40547 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40548 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40549 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40550 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40551 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40552 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40553 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40554 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40555 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40556 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40557 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40558 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40559 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40560 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40561 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40562 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40563 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40564 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40565 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40566 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40567 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40568 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40569 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40570 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40571 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40572 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40573 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40574 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40575 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40576 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40577 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40578 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40579 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40580 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40581 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40582 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40583 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40584 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40585 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40586 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40587 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40588 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40589 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40590 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40591 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40592 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40593 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40594 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40595 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40596 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40597 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40598 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40599 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40600 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40601 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40602 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40603 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40604 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40605 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40606 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40607 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40608 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40609 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40610 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40611 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40612 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40613 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40614 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40615 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40616 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40617 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40618 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40619 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40620 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40621 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40622 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40623 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40624 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40625 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40626 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40627 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40628 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40629 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40630 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40631 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40632 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40633 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40634 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40635 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40636 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40637 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40638 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40639 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40640 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40641 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40642 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40643 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40644 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40645 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40646 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40647 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40648 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40649 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40650 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40651 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40652 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40653 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40654 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40655 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40656 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40657 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40658 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40659 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40660 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40661 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40662 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40663 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40664 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40665 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40666 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40667 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40668 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40669 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40670 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40671 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40672 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40673 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40674 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40675 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40676 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40677 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40678 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40679 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40680 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40681 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40682 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40683 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40684
40685 static swig_type_info *swig_type_initial[] = {
40686 &_swigt__p_char,
40687 &_swigt__p_form_ops_t,
40688 &_swigt__p_int,
40689 &_swigt__p_unsigned_char,
40690 &_swigt__p_unsigned_int,
40691 &_swigt__p_unsigned_long,
40692 &_swigt__p_void,
40693 &_swigt__p_wxANIHandler,
40694 &_swigt__p_wxAboutDialogInfo,
40695 &_swigt__p_wxAcceleratorTable,
40696 &_swigt__p_wxActivateEvent,
40697 &_swigt__p_wxArrayString,
40698 &_swigt__p_wxBMPHandler,
40699 &_swigt__p_wxBitmap,
40700 &_swigt__p_wxBitmapDataObject,
40701 &_swigt__p_wxBoxSizer,
40702 &_swigt__p_wxBusyCursor,
40703 &_swigt__p_wxBusyInfo,
40704 &_swigt__p_wxCURHandler,
40705 &_swigt__p_wxCaret,
40706 &_swigt__p_wxChar,
40707 &_swigt__p_wxChildFocusEvent,
40708 &_swigt__p_wxClipboard,
40709 &_swigt__p_wxClipboardLocker,
40710 &_swigt__p_wxClipboardTextEvent,
40711 &_swigt__p_wxCloseEvent,
40712 &_swigt__p_wxColour,
40713 &_swigt__p_wxCommandEvent,
40714 &_swigt__p_wxConfig,
40715 &_swigt__p_wxConfigBase,
40716 &_swigt__p_wxConfigPathChanger,
40717 &_swigt__p_wxContextMenuEvent,
40718 &_swigt__p_wxControl,
40719 &_swigt__p_wxControlWithItems,
40720 &_swigt__p_wxCursor,
40721 &_swigt__p_wxCustomDataObject,
40722 &_swigt__p_wxDC,
40723 &_swigt__p_wxDataFormat,
40724 &_swigt__p_wxDataObject,
40725 &_swigt__p_wxDataObjectComposite,
40726 &_swigt__p_wxDataObjectSimple,
40727 &_swigt__p_wxDateEvent,
40728 &_swigt__p_wxDateSpan,
40729 &_swigt__p_wxDateTime,
40730 &_swigt__p_wxDateTime__TimeZone,
40731 &_swigt__p_wxDisplay,
40732 &_swigt__p_wxDisplayChangedEvent,
40733 &_swigt__p_wxDropFilesEvent,
40734 &_swigt__p_wxDuplexMode,
40735 &_swigt__p_wxEraseEvent,
40736 &_swigt__p_wxEvent,
40737 &_swigt__p_wxEvtHandler,
40738 &_swigt__p_wxFSFile,
40739 &_swigt__p_wxFileConfig,
40740 &_swigt__p_wxFileDataObject,
40741 &_swigt__p_wxFileHistory,
40742 &_swigt__p_wxFileSystem,
40743 &_swigt__p_wxFileType,
40744 &_swigt__p_wxFileTypeInfo,
40745 &_swigt__p_wxFlexGridSizer,
40746 &_swigt__p_wxFocusEvent,
40747 &_swigt__p_wxFont,
40748 &_swigt__p_wxFrame,
40749 &_swigt__p_wxGBSizerItem,
40750 &_swigt__p_wxGIFHandler,
40751 &_swigt__p_wxGridBagSizer,
40752 &_swigt__p_wxGridSizer,
40753 &_swigt__p_wxICOHandler,
40754 &_swigt__p_wxIcon,
40755 &_swigt__p_wxIconizeEvent,
40756 &_swigt__p_wxIdleEvent,
40757 &_swigt__p_wxImage,
40758 &_swigt__p_wxImageHandler,
40759 &_swigt__p_wxIndividualLayoutConstraint,
40760 &_swigt__p_wxInitDialogEvent,
40761 &_swigt__p_wxJPEGHandler,
40762 &_swigt__p_wxJoystick,
40763 &_swigt__p_wxJoystickEvent,
40764 &_swigt__p_wxKeyEvent,
40765 &_swigt__p_wxKillError,
40766 &_swigt__p_wxLayoutConstraints,
40767 &_swigt__p_wxLog,
40768 &_swigt__p_wxLogBuffer,
40769 &_swigt__p_wxLogChain,
40770 &_swigt__p_wxLogGui,
40771 &_swigt__p_wxLogNull,
40772 &_swigt__p_wxLogStderr,
40773 &_swigt__p_wxLogTextCtrl,
40774 &_swigt__p_wxLogWindow,
40775 &_swigt__p_wxMaximizeEvent,
40776 &_swigt__p_wxMenu,
40777 &_swigt__p_wxMenuBar,
40778 &_swigt__p_wxMenuEvent,
40779 &_swigt__p_wxMenuItem,
40780 &_swigt__p_wxMetafileDataObject,
40781 &_swigt__p_wxMimeTypesManager,
40782 &_swigt__p_wxMouseCaptureChangedEvent,
40783 &_swigt__p_wxMouseCaptureLostEvent,
40784 &_swigt__p_wxMouseEvent,
40785 &_swigt__p_wxMouseState,
40786 &_swigt__p_wxMoveEvent,
40787 &_swigt__p_wxMutexGuiLocker,
40788 &_swigt__p_wxNavigationKeyEvent,
40789 &_swigt__p_wxNcPaintEvent,
40790 &_swigt__p_wxNotifyEvent,
40791 &_swigt__p_wxObject,
40792 &_swigt__p_wxOutputStream,
40793 &_swigt__p_wxPCXHandler,
40794 &_swigt__p_wxPNGHandler,
40795 &_swigt__p_wxPNMHandler,
40796 &_swigt__p_wxPaintEvent,
40797 &_swigt__p_wxPaletteChangedEvent,
40798 &_swigt__p_wxPaperSize,
40799 &_swigt__p_wxPlatformInfo,
40800 &_swigt__p_wxPoint,
40801 &_swigt__p_wxPowerEvent,
40802 &_swigt__p_wxProcessEvent,
40803 &_swigt__p_wxPyApp,
40804 &_swigt__p_wxPyArtProvider,
40805 &_swigt__p_wxPyBitmapDataObject,
40806 &_swigt__p_wxPyCommandEvent,
40807 &_swigt__p_wxPyDataObjectSimple,
40808 &_swigt__p_wxPyDropSource,
40809 &_swigt__p_wxPyDropTarget,
40810 &_swigt__p_wxPyEvent,
40811 &_swigt__p_wxPyFileDropTarget,
40812 &_swigt__p_wxPyImageHandler,
40813 &_swigt__p_wxPyLog,
40814 &_swigt__p_wxPyProcess,
40815 &_swigt__p_wxPySizer,
40816 &_swigt__p_wxPyTextDataObject,
40817 &_swigt__p_wxPyTextDropTarget,
40818 &_swigt__p_wxPyTimer,
40819 &_swigt__p_wxPyTipProvider,
40820 &_swigt__p_wxPyValidator,
40821 &_swigt__p_wxQueryNewPaletteEvent,
40822 &_swigt__p_wxRect,
40823 &_swigt__p_wxScrollEvent,
40824 &_swigt__p_wxScrollWinEvent,
40825 &_swigt__p_wxSetCursorEvent,
40826 &_swigt__p_wxShowEvent,
40827 &_swigt__p_wxSingleInstanceChecker,
40828 &_swigt__p_wxSize,
40829 &_swigt__p_wxSizeEvent,
40830 &_swigt__p_wxSizer,
40831 &_swigt__p_wxSizerItem,
40832 &_swigt__p_wxSound,
40833 &_swigt__p_wxStandardPaths,
40834 &_swigt__p_wxStaticBoxSizer,
40835 &_swigt__p_wxStdDialogButtonSizer,
40836 &_swigt__p_wxStopWatch,
40837 &_swigt__p_wxString,
40838 &_swigt__p_wxSysColourChangedEvent,
40839 &_swigt__p_wxSystemOptions,
40840 &_swigt__p_wxSystemSettings,
40841 &_swigt__p_wxTIFFHandler,
40842 &_swigt__p_wxTextCtrl,
40843 &_swigt__p_wxTextDataObject,
40844 &_swigt__p_wxTimeSpan,
40845 &_swigt__p_wxTimer,
40846 &_swigt__p_wxTimerEvent,
40847 &_swigt__p_wxTimerRunner,
40848 &_swigt__p_wxTipProvider,
40849 &_swigt__p_wxToolTip,
40850 &_swigt__p_wxURLDataObject,
40851 &_swigt__p_wxUpdateUIEvent,
40852 &_swigt__p_wxValidator,
40853 &_swigt__p_wxVideoMode,
40854 &_swigt__p_wxWindow,
40855 &_swigt__p_wxWindowCreateEvent,
40856 &_swigt__p_wxWindowDestroyEvent,
40857 &_swigt__p_wxWindowDisabler,
40858 &_swigt__p_wxXPMHandler,
40859 };
40860
40861 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
40862 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
40863 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
40864 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
40865 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
40866 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
40867 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
40868 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
40869 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
40870 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
40871 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}};
40872 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
40873 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
40874 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
40875 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
40876 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
40877 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
40878 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
40879 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
40880 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}};
40881 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
40882 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
40883 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
40884 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
40885 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
40886 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}};
40887 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
40888 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}};
40889 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
40890 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
40891 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
40892 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
40893 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
40894 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
40895 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
40896 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
40897 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
40898 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
40899 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
40900 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
40901 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
40902 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
40903 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
40904 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
40905 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
40906 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
40907 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
40908 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
40909 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
40910 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
40911 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
40912 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
40913 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
40914 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
40915 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
40916 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
40917 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
40918 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
40919 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
40920 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
40921 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
40922 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
40923 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
40924 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
40925 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
40926 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
40927 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
40928 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
40929 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
40930 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
40931 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
40932 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
40933 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
40934 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
40935 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
40936 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
40937 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
40938 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
40939 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}};
40940 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
40941 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
40942 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
40943 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
40944 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
40945 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
40946 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
40947 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
40948 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
40949 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
40950 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
40951 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}};
40952 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
40953 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
40954 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
40955 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
40956 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
40957 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
40958 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
40959 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
40960 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
40961 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
40962 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
40963 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
40964 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
40965 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
40966 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
40967 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
40968 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
40969 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
40970 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
40971 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
40972 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
40973 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
40974 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
40975 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
40976 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
40977 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
40978 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
40979 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
40980 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
40981 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
40982 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
40983 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
40984 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
40985 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
40986 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
40987 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
40988 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
40989 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
40990 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
40991 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
40992 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
40993 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
40994 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
40995 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
40996 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
40997 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
40998 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
40999 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41000 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41001 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41002 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41003 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41004 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41005 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}};
41006 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41007 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41008 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41009 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41010 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41011 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41012 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41013 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41014 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41015 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41016 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41017 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41018 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41019 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41020 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41021 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41022 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41023 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}};
41024 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41025 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41026 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41027 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41028 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}};
41029 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41030 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41031 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41032 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}};
41033 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41034
41035 static swig_cast_info *swig_cast_initial[] = {
41036 _swigc__p_char,
41037 _swigc__p_form_ops_t,
41038 _swigc__p_int,
41039 _swigc__p_unsigned_char,
41040 _swigc__p_unsigned_int,
41041 _swigc__p_unsigned_long,
41042 _swigc__p_void,
41043 _swigc__p_wxANIHandler,
41044 _swigc__p_wxAboutDialogInfo,
41045 _swigc__p_wxAcceleratorTable,
41046 _swigc__p_wxActivateEvent,
41047 _swigc__p_wxArrayString,
41048 _swigc__p_wxBMPHandler,
41049 _swigc__p_wxBitmap,
41050 _swigc__p_wxBitmapDataObject,
41051 _swigc__p_wxBoxSizer,
41052 _swigc__p_wxBusyCursor,
41053 _swigc__p_wxBusyInfo,
41054 _swigc__p_wxCURHandler,
41055 _swigc__p_wxCaret,
41056 _swigc__p_wxChar,
41057 _swigc__p_wxChildFocusEvent,
41058 _swigc__p_wxClipboard,
41059 _swigc__p_wxClipboardLocker,
41060 _swigc__p_wxClipboardTextEvent,
41061 _swigc__p_wxCloseEvent,
41062 _swigc__p_wxColour,
41063 _swigc__p_wxCommandEvent,
41064 _swigc__p_wxConfig,
41065 _swigc__p_wxConfigBase,
41066 _swigc__p_wxConfigPathChanger,
41067 _swigc__p_wxContextMenuEvent,
41068 _swigc__p_wxControl,
41069 _swigc__p_wxControlWithItems,
41070 _swigc__p_wxCursor,
41071 _swigc__p_wxCustomDataObject,
41072 _swigc__p_wxDC,
41073 _swigc__p_wxDataFormat,
41074 _swigc__p_wxDataObject,
41075 _swigc__p_wxDataObjectComposite,
41076 _swigc__p_wxDataObjectSimple,
41077 _swigc__p_wxDateEvent,
41078 _swigc__p_wxDateSpan,
41079 _swigc__p_wxDateTime,
41080 _swigc__p_wxDateTime__TimeZone,
41081 _swigc__p_wxDisplay,
41082 _swigc__p_wxDisplayChangedEvent,
41083 _swigc__p_wxDropFilesEvent,
41084 _swigc__p_wxDuplexMode,
41085 _swigc__p_wxEraseEvent,
41086 _swigc__p_wxEvent,
41087 _swigc__p_wxEvtHandler,
41088 _swigc__p_wxFSFile,
41089 _swigc__p_wxFileConfig,
41090 _swigc__p_wxFileDataObject,
41091 _swigc__p_wxFileHistory,
41092 _swigc__p_wxFileSystem,
41093 _swigc__p_wxFileType,
41094 _swigc__p_wxFileTypeInfo,
41095 _swigc__p_wxFlexGridSizer,
41096 _swigc__p_wxFocusEvent,
41097 _swigc__p_wxFont,
41098 _swigc__p_wxFrame,
41099 _swigc__p_wxGBSizerItem,
41100 _swigc__p_wxGIFHandler,
41101 _swigc__p_wxGridBagSizer,
41102 _swigc__p_wxGridSizer,
41103 _swigc__p_wxICOHandler,
41104 _swigc__p_wxIcon,
41105 _swigc__p_wxIconizeEvent,
41106 _swigc__p_wxIdleEvent,
41107 _swigc__p_wxImage,
41108 _swigc__p_wxImageHandler,
41109 _swigc__p_wxIndividualLayoutConstraint,
41110 _swigc__p_wxInitDialogEvent,
41111 _swigc__p_wxJPEGHandler,
41112 _swigc__p_wxJoystick,
41113 _swigc__p_wxJoystickEvent,
41114 _swigc__p_wxKeyEvent,
41115 _swigc__p_wxKillError,
41116 _swigc__p_wxLayoutConstraints,
41117 _swigc__p_wxLog,
41118 _swigc__p_wxLogBuffer,
41119 _swigc__p_wxLogChain,
41120 _swigc__p_wxLogGui,
41121 _swigc__p_wxLogNull,
41122 _swigc__p_wxLogStderr,
41123 _swigc__p_wxLogTextCtrl,
41124 _swigc__p_wxLogWindow,
41125 _swigc__p_wxMaximizeEvent,
41126 _swigc__p_wxMenu,
41127 _swigc__p_wxMenuBar,
41128 _swigc__p_wxMenuEvent,
41129 _swigc__p_wxMenuItem,
41130 _swigc__p_wxMetafileDataObject,
41131 _swigc__p_wxMimeTypesManager,
41132 _swigc__p_wxMouseCaptureChangedEvent,
41133 _swigc__p_wxMouseCaptureLostEvent,
41134 _swigc__p_wxMouseEvent,
41135 _swigc__p_wxMouseState,
41136 _swigc__p_wxMoveEvent,
41137 _swigc__p_wxMutexGuiLocker,
41138 _swigc__p_wxNavigationKeyEvent,
41139 _swigc__p_wxNcPaintEvent,
41140 _swigc__p_wxNotifyEvent,
41141 _swigc__p_wxObject,
41142 _swigc__p_wxOutputStream,
41143 _swigc__p_wxPCXHandler,
41144 _swigc__p_wxPNGHandler,
41145 _swigc__p_wxPNMHandler,
41146 _swigc__p_wxPaintEvent,
41147 _swigc__p_wxPaletteChangedEvent,
41148 _swigc__p_wxPaperSize,
41149 _swigc__p_wxPlatformInfo,
41150 _swigc__p_wxPoint,
41151 _swigc__p_wxPowerEvent,
41152 _swigc__p_wxProcessEvent,
41153 _swigc__p_wxPyApp,
41154 _swigc__p_wxPyArtProvider,
41155 _swigc__p_wxPyBitmapDataObject,
41156 _swigc__p_wxPyCommandEvent,
41157 _swigc__p_wxPyDataObjectSimple,
41158 _swigc__p_wxPyDropSource,
41159 _swigc__p_wxPyDropTarget,
41160 _swigc__p_wxPyEvent,
41161 _swigc__p_wxPyFileDropTarget,
41162 _swigc__p_wxPyImageHandler,
41163 _swigc__p_wxPyLog,
41164 _swigc__p_wxPyProcess,
41165 _swigc__p_wxPySizer,
41166 _swigc__p_wxPyTextDataObject,
41167 _swigc__p_wxPyTextDropTarget,
41168 _swigc__p_wxPyTimer,
41169 _swigc__p_wxPyTipProvider,
41170 _swigc__p_wxPyValidator,
41171 _swigc__p_wxQueryNewPaletteEvent,
41172 _swigc__p_wxRect,
41173 _swigc__p_wxScrollEvent,
41174 _swigc__p_wxScrollWinEvent,
41175 _swigc__p_wxSetCursorEvent,
41176 _swigc__p_wxShowEvent,
41177 _swigc__p_wxSingleInstanceChecker,
41178 _swigc__p_wxSize,
41179 _swigc__p_wxSizeEvent,
41180 _swigc__p_wxSizer,
41181 _swigc__p_wxSizerItem,
41182 _swigc__p_wxSound,
41183 _swigc__p_wxStandardPaths,
41184 _swigc__p_wxStaticBoxSizer,
41185 _swigc__p_wxStdDialogButtonSizer,
41186 _swigc__p_wxStopWatch,
41187 _swigc__p_wxString,
41188 _swigc__p_wxSysColourChangedEvent,
41189 _swigc__p_wxSystemOptions,
41190 _swigc__p_wxSystemSettings,
41191 _swigc__p_wxTIFFHandler,
41192 _swigc__p_wxTextCtrl,
41193 _swigc__p_wxTextDataObject,
41194 _swigc__p_wxTimeSpan,
41195 _swigc__p_wxTimer,
41196 _swigc__p_wxTimerEvent,
41197 _swigc__p_wxTimerRunner,
41198 _swigc__p_wxTipProvider,
41199 _swigc__p_wxToolTip,
41200 _swigc__p_wxURLDataObject,
41201 _swigc__p_wxUpdateUIEvent,
41202 _swigc__p_wxValidator,
41203 _swigc__p_wxVideoMode,
41204 _swigc__p_wxWindow,
41205 _swigc__p_wxWindowCreateEvent,
41206 _swigc__p_wxWindowDestroyEvent,
41207 _swigc__p_wxWindowDisabler,
41208 _swigc__p_wxXPMHandler,
41209 };
41210
41211
41212 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41213
41214 static swig_const_info swig_const_table[] = {
41215 {0, 0, 0, 0.0, 0, 0}};
41216
41217 #ifdef __cplusplus
41218 }
41219 #endif
41220 /* -----------------------------------------------------------------------------
41221 * Type initialization:
41222 * This problem is tough by the requirement that no dynamic
41223 * memory is used. Also, since swig_type_info structures store pointers to
41224 * swig_cast_info structures and swig_cast_info structures store pointers back
41225 * to swig_type_info structures, we need some lookup code at initialization.
41226 * The idea is that swig generates all the structures that are needed.
41227 * The runtime then collects these partially filled structures.
41228 * The SWIG_InitializeModule function takes these initial arrays out of
41229 * swig_module, and does all the lookup, filling in the swig_module.types
41230 * array with the correct data and linking the correct swig_cast_info
41231 * structures together.
41232 *
41233 * The generated swig_type_info structures are assigned staticly to an initial
41234 * array. We just loop though that array, and handle each type individually.
41235 * First we lookup if this type has been already loaded, and if so, use the
41236 * loaded structure instead of the generated one. Then we have to fill in the
41237 * cast linked list. The cast data is initially stored in something like a
41238 * two-dimensional array. Each row corresponds to a type (there are the same
41239 * number of rows as there are in the swig_type_initial array). Each entry in
41240 * a column is one of the swig_cast_info structures for that type.
41241 * The cast_initial array is actually an array of arrays, because each row has
41242 * a variable number of columns. So to actually build the cast linked list,
41243 * we find the array of casts associated with the type, and loop through it
41244 * adding the casts to the list. The one last trick we need to do is making
41245 * sure the type pointer in the swig_cast_info struct is correct.
41246 *
41247 * First off, we lookup the cast->type name to see if it is already loaded.
41248 * There are three cases to handle:
41249 * 1) If the cast->type has already been loaded AND the type we are adding
41250 * casting info to has not been loaded (it is in this module), THEN we
41251 * replace the cast->type pointer with the type pointer that has already
41252 * been loaded.
41253 * 2) If BOTH types (the one we are adding casting info to, and the
41254 * cast->type) are loaded, THEN the cast info has already been loaded by
41255 * the previous module so we just ignore it.
41256 * 3) Finally, if cast->type has not already been loaded, then we add that
41257 * swig_cast_info to the linked list (because the cast->type) pointer will
41258 * be correct.
41259 * ----------------------------------------------------------------------------- */
41260
41261 #ifdef __cplusplus
41262 extern "C" {
41263 #if 0
41264 } /* c-mode */
41265 #endif
41266 #endif
41267
41268 #if 0
41269 #define SWIGRUNTIME_DEBUG
41270 #endif
41271
41272 SWIGRUNTIME void
41273 SWIG_InitializeModule(void *clientdata) {
41274 size_t i;
41275 swig_module_info *module_head;
41276 static int init_run = 0;
41277
41278 clientdata = clientdata;
41279
41280 if (init_run) return;
41281 init_run = 1;
41282
41283 /* Initialize the swig_module */
41284 swig_module.type_initial = swig_type_initial;
41285 swig_module.cast_initial = swig_cast_initial;
41286
41287 /* Try and load any already created modules */
41288 module_head = SWIG_GetModule(clientdata);
41289 if (module_head) {
41290 swig_module.next = module_head->next;
41291 module_head->next = &swig_module;
41292 } else {
41293 /* This is the first module loaded */
41294 swig_module.next = &swig_module;
41295 SWIG_SetModule(clientdata, &swig_module);
41296 }
41297
41298 /* Now work on filling in swig_module.types */
41299 #ifdef SWIGRUNTIME_DEBUG
41300 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41301 #endif
41302 for (i = 0; i < swig_module.size; ++i) {
41303 swig_type_info *type = 0;
41304 swig_type_info *ret;
41305 swig_cast_info *cast;
41306
41307 #ifdef SWIGRUNTIME_DEBUG
41308 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41309 #endif
41310
41311 /* if there is another module already loaded */
41312 if (swig_module.next != &swig_module) {
41313 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41314 }
41315 if (type) {
41316 /* Overwrite clientdata field */
41317 #ifdef SWIGRUNTIME_DEBUG
41318 printf("SWIG_InitializeModule: found type %s\n", type->name);
41319 #endif
41320 if (swig_module.type_initial[i]->clientdata) {
41321 type->clientdata = swig_module.type_initial[i]->clientdata;
41322 #ifdef SWIGRUNTIME_DEBUG
41323 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41324 #endif
41325 }
41326 } else {
41327 type = swig_module.type_initial[i];
41328 }
41329
41330 /* Insert casting types */
41331 cast = swig_module.cast_initial[i];
41332 while (cast->type) {
41333 /* Don't need to add information already in the list */
41334 ret = 0;
41335 #ifdef SWIGRUNTIME_DEBUG
41336 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41337 #endif
41338 if (swig_module.next != &swig_module) {
41339 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41340 #ifdef SWIGRUNTIME_DEBUG
41341 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41342 #endif
41343 }
41344 if (ret) {
41345 if (type == swig_module.type_initial[i]) {
41346 #ifdef SWIGRUNTIME_DEBUG
41347 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41348 #endif
41349 cast->type = ret;
41350 ret = 0;
41351 } else {
41352 /* Check for casting already in the list */
41353 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41354 #ifdef SWIGRUNTIME_DEBUG
41355 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41356 #endif
41357 if (!ocast) ret = 0;
41358 }
41359 }
41360
41361 if (!ret) {
41362 #ifdef SWIGRUNTIME_DEBUG
41363 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41364 #endif
41365 if (type->cast) {
41366 type->cast->prev = cast;
41367 cast->next = type->cast;
41368 }
41369 type->cast = cast;
41370 }
41371 cast++;
41372 }
41373 /* Set entry in modules->types array equal to the type */
41374 swig_module.types[i] = type;
41375 }
41376 swig_module.types[i] = 0;
41377
41378 #ifdef SWIGRUNTIME_DEBUG
41379 printf("**** SWIG_InitializeModule: Cast List ******\n");
41380 for (i = 0; i < swig_module.size; ++i) {
41381 int j = 0;
41382 swig_cast_info *cast = swig_module.cast_initial[i];
41383 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41384 while (cast->type) {
41385 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41386 cast++;
41387 ++j;
41388 }
41389 printf("---- Total casts: %d\n",j);
41390 }
41391 printf("**** SWIG_InitializeModule: Cast List ******\n");
41392 #endif
41393 }
41394
41395 /* This function will propagate the clientdata field of type to
41396 * any new swig_type_info structures that have been added into the list
41397 * of equivalent types. It is like calling
41398 * SWIG_TypeClientData(type, clientdata) a second time.
41399 */
41400 SWIGRUNTIME void
41401 SWIG_PropagateClientData(void) {
41402 size_t i;
41403 swig_cast_info *equiv;
41404 static int init_run = 0;
41405
41406 if (init_run) return;
41407 init_run = 1;
41408
41409 for (i = 0; i < swig_module.size; i++) {
41410 if (swig_module.types[i]->clientdata) {
41411 equiv = swig_module.types[i]->cast;
41412 while (equiv) {
41413 if (!equiv->converter) {
41414 if (equiv->type && !equiv->type->clientdata)
41415 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41416 }
41417 equiv = equiv->next;
41418 }
41419 }
41420 }
41421 }
41422
41423 #ifdef __cplusplus
41424 #if 0
41425 {
41426 /* c-mode */
41427 #endif
41428 }
41429 #endif
41430
41431
41432
41433 #ifdef __cplusplus
41434 extern "C" {
41435 #endif
41436
41437 /* Python-specific SWIG API */
41438 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41439 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41440 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41441
41442 /* -----------------------------------------------------------------------------
41443 * global variable support code.
41444 * ----------------------------------------------------------------------------- */
41445
41446 typedef struct swig_globalvar {
41447 char *name; /* Name of global variable */
41448 PyObject *(*get_attr)(void); /* Return the current value */
41449 int (*set_attr)(PyObject *); /* Set the value */
41450 struct swig_globalvar *next;
41451 } swig_globalvar;
41452
41453 typedef struct swig_varlinkobject {
41454 PyObject_HEAD
41455 swig_globalvar *vars;
41456 } swig_varlinkobject;
41457
41458 SWIGINTERN PyObject *
41459 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41460 return PyString_FromString("<Swig global variables>");
41461 }
41462
41463 SWIGINTERN PyObject *
41464 swig_varlink_str(swig_varlinkobject *v) {
41465 PyObject *str = PyString_FromString("(");
41466 swig_globalvar *var;
41467 for (var = v->vars; var; var=var->next) {
41468 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41469 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41470 }
41471 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41472 return str;
41473 }
41474
41475 SWIGINTERN int
41476 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41477 PyObject *str = swig_varlink_str(v);
41478 fprintf(fp,"Swig global variables ");
41479 fprintf(fp,"%s\n", PyString_AsString(str));
41480 Py_DECREF(str);
41481 return 0;
41482 }
41483
41484 SWIGINTERN void
41485 swig_varlink_dealloc(swig_varlinkobject *v) {
41486 swig_globalvar *var = v->vars;
41487 while (var) {
41488 swig_globalvar *n = var->next;
41489 free(var->name);
41490 free(var);
41491 var = n;
41492 }
41493 }
41494
41495 SWIGINTERN PyObject *
41496 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41497 PyObject *res = NULL;
41498 swig_globalvar *var = v->vars;
41499 while (var) {
41500 if (strcmp(var->name,n) == 0) {
41501 res = (*var->get_attr)();
41502 break;
41503 }
41504 var = var->next;
41505 }
41506 if (res == NULL && !PyErr_Occurred()) {
41507 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41508 }
41509 return res;
41510 }
41511
41512 SWIGINTERN int
41513 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41514 int res = 1;
41515 swig_globalvar *var = v->vars;
41516 while (var) {
41517 if (strcmp(var->name,n) == 0) {
41518 res = (*var->set_attr)(p);
41519 break;
41520 }
41521 var = var->next;
41522 }
41523 if (res == 1 && !PyErr_Occurred()) {
41524 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41525 }
41526 return res;
41527 }
41528
41529 SWIGINTERN PyTypeObject*
41530 swig_varlink_type(void) {
41531 static char varlink__doc__[] = "Swig var link object";
41532 static PyTypeObject varlink_type;
41533 static int type_init = 0;
41534 if (!type_init) {
41535 const PyTypeObject tmp
41536 = {
41537 PyObject_HEAD_INIT(NULL)
41538 0, /* Number of items in variable part (ob_size) */
41539 (char *)"swigvarlink", /* Type name (tp_name) */
41540 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41541 0, /* Itemsize (tp_itemsize) */
41542 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41543 (printfunc) swig_varlink_print, /* Print (tp_print) */
41544 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41545 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41546 0, /* tp_compare */
41547 (reprfunc) swig_varlink_repr, /* tp_repr */
41548 0, /* tp_as_number */
41549 0, /* tp_as_sequence */
41550 0, /* tp_as_mapping */
41551 0, /* tp_hash */
41552 0, /* tp_call */
41553 (reprfunc)swig_varlink_str, /* tp_str */
41554 0, /* tp_getattro */
41555 0, /* tp_setattro */
41556 0, /* tp_as_buffer */
41557 0, /* tp_flags */
41558 varlink__doc__, /* tp_doc */
41559 0, /* tp_traverse */
41560 0, /* tp_clear */
41561 0, /* tp_richcompare */
41562 0, /* tp_weaklistoffset */
41563 #if PY_VERSION_HEX >= 0x02020000
41564 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41565 #endif
41566 #if PY_VERSION_HEX >= 0x02030000
41567 0, /* tp_del */
41568 #endif
41569 #ifdef COUNT_ALLOCS
41570 0,0,0,0 /* tp_alloc -> tp_next */
41571 #endif
41572 };
41573 varlink_type = tmp;
41574 varlink_type.ob_type = &PyType_Type;
41575 type_init = 1;
41576 }
41577 return &varlink_type;
41578 }
41579
41580 /* Create a variable linking object for use later */
41581 SWIGINTERN PyObject *
41582 SWIG_Python_newvarlink(void) {
41583 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41584 if (result) {
41585 result->vars = 0;
41586 }
41587 return ((PyObject*) result);
41588 }
41589
41590 SWIGINTERN void
41591 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41592 swig_varlinkobject *v = (swig_varlinkobject *) p;
41593 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41594 if (gv) {
41595 size_t size = strlen(name)+1;
41596 gv->name = (char *)malloc(size);
41597 if (gv->name) {
41598 strncpy(gv->name,name,size);
41599 gv->get_attr = get_attr;
41600 gv->set_attr = set_attr;
41601 gv->next = v->vars;
41602 }
41603 }
41604 v->vars = gv;
41605 }
41606
41607 SWIGINTERN PyObject *
41608 SWIG_globals() {
41609 static PyObject *_SWIG_globals = 0;
41610 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41611 return _SWIG_globals;
41612 }
41613
41614 /* -----------------------------------------------------------------------------
41615 * constants/methods manipulation
41616 * ----------------------------------------------------------------------------- */
41617
41618 /* Install Constants */
41619 SWIGINTERN void
41620 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41621 PyObject *obj = 0;
41622 size_t i;
41623 for (i = 0; constants[i].type; ++i) {
41624 switch(constants[i].type) {
41625 case SWIG_PY_POINTER:
41626 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41627 break;
41628 case SWIG_PY_BINARY:
41629 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41630 break;
41631 default:
41632 obj = 0;
41633 break;
41634 }
41635 if (obj) {
41636 PyDict_SetItemString(d, constants[i].name, obj);
41637 Py_DECREF(obj);
41638 }
41639 }
41640 }
41641
41642 /* -----------------------------------------------------------------------------*/
41643 /* Fix SwigMethods to carry the callback ptrs when needed */
41644 /* -----------------------------------------------------------------------------*/
41645
41646 SWIGINTERN void
41647 SWIG_Python_FixMethods(PyMethodDef *methods,
41648 swig_const_info *const_table,
41649 swig_type_info **types,
41650 swig_type_info **types_initial) {
41651 size_t i;
41652 for (i = 0; methods[i].ml_name; ++i) {
41653 const char *c = methods[i].ml_doc;
41654 if (c && (c = strstr(c, "swig_ptr: "))) {
41655 int j;
41656 swig_const_info *ci = 0;
41657 const char *name = c + 10;
41658 for (j = 0; const_table[j].type; ++j) {
41659 if (strncmp(const_table[j].name, name,
41660 strlen(const_table[j].name)) == 0) {
41661 ci = &(const_table[j]);
41662 break;
41663 }
41664 }
41665 if (ci) {
41666 size_t shift = (ci->ptype) - types;
41667 swig_type_info *ty = types_initial[shift];
41668 size_t ldoc = (c - methods[i].ml_doc);
41669 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41670 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41671 if (ndoc) {
41672 char *buff = ndoc;
41673 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41674 if (ptr) {
41675 strncpy(buff, methods[i].ml_doc, ldoc);
41676 buff += ldoc;
41677 strncpy(buff, "swig_ptr: ", 10);
41678 buff += 10;
41679 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41680 methods[i].ml_doc = ndoc;
41681 }
41682 }
41683 }
41684 }
41685 }
41686 }
41687
41688 #ifdef __cplusplus
41689 }
41690 #endif
41691
41692 /* -----------------------------------------------------------------------------*
41693 * Partial Init method
41694 * -----------------------------------------------------------------------------*/
41695
41696 #ifdef __cplusplus
41697 extern "C"
41698 #endif
41699 SWIGEXPORT void SWIG_init(void) {
41700 PyObject *m, *d;
41701
41702 /* Fix SwigMethods to carry the callback ptrs when needed */
41703 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41704
41705 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41706 d = PyModule_GetDict(m);
41707
41708 SWIG_InitializeModule(0);
41709 SWIG_InstallConstants(d,swig_const_table);
41710
41711
41712 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41713 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41714 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41715 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41716 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41717 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41718 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41719 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41720 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41721 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41722 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41723 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41724 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41725 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41726 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41727 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41728 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41729 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41730 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41731 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41732 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41733 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41734 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41735 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41736 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41737 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41738 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41739 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41740 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41741 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41742 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41743 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41744 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41745 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41746 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41747 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41748 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41749 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41750 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41751 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41752 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41753 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41754 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41755 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41756 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41757 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41758 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41759 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41760 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41761 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41762 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41763 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41764 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41765 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41766 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41767 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41768 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41769 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41770 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41771 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41772 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41773 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41774 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41775 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41776 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41777 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41778 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41779 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41780 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41781 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41782 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41783 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41784 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41785 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41786 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41787 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41788 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41789 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41790 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41791 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41792 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41793 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41794 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41795 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41796 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41797 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41798 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41799 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41800 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41801 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41802 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41803 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41804 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41805 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41806 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41807 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41808 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41809 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41810 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41811 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41812 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41813 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41814 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
41815 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
41816 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
41817 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
41818 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
41819 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
41820 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
41821 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
41822 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
41823 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
41824 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
41825 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
41826 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
41827 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
41828 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
41829 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
41830 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
41831 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
41832 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
41833 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
41834 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
41835 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
41836 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
41837 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
41838 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
41839 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
41840 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
41841 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
41842 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
41843 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
41844 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
41845 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
41846 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
41847 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
41848 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
41849 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
41850 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
41851 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
41852 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
41853 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
41854 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
41855 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
41856 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
41857 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
41858 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
41859 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
41860
41861 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
41862
41863 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
41864 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
41865 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
41866 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
41867 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
41868 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
41869 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
41870 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
41871 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
41872 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
41873 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
41874 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
41875 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
41876 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
41877 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
41878 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
41879 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
41880 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
41881 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
41882 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
41883 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
41884 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
41885 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
41886 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
41887 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
41888 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
41889 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
41890 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
41891 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
41892 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
41893 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
41894 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
41895 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
41896 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
41897 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
41898 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
41899 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
41900 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
41901 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
41902 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
41903 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
41904 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
41905 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
41906 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
41907 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
41908 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
41909 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
41910 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
41911 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
41912 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
41913 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
41914 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
41915 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
41916
41917 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
41918
41919 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
41920 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
41921 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
41922 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
41923 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
41924 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
41925 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
41926 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
41927 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
41928 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
41929 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
41930 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
41931 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
41932 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
41933 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
41934 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
41935 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
41936 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
41937 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
41938 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
41939 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
41940 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
41941 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
41942 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
41943 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
41944 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
41945 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
41946 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
41947 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
41948 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
41949 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
41950 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
41951 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
41952 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
41953 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
41954 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
41955 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
41956 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
41957 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
41958 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
41959 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
41960 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
41961 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
41962 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
41963 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
41964 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
41965 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
41966 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
41967 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
41968 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
41969 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
41970 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
41971 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
41972 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
41973 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
41974 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
41975 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
41976 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
41977 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
41978 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
41979 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
41980 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
41981 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
41982 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
41983 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
41984 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
41985 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
41986 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
41987 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
41988 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
41989 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
41990 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
41991 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
41992 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
41993 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
41994 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
41995
41996 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
41997
41998 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
41999 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42000 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42001 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42002 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42003 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42004 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42005 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42006 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42007 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42008 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42009 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42010 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42011 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42012 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42013 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42014 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42015 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42016 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42017 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42018 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42019 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42020 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42021 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42022 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42023 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42024 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42025 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42026 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42027 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42028 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42029 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42030 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42031 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42032 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42033 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42034 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42035 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42036 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42037 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42038 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42039 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42040 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42041 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42042 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42043 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42044 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42045 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42046 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42047 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42048 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42049 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42050 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42051 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42052 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42053 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42054 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42055 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42056 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42057 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42058 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42059 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42060 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42061 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42062 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42063 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42064 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42065 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42066 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42067 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42068 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42069 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42070 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42071 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42072 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42073 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42074 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42075 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42076 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42077 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42078 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42079 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42080 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42081 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42082 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42083 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42084 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42085 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42086 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42087 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42088 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42089 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42090 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42091 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42092 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42093 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42094 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42095 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42096 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42097 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42098 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42099 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42100 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42101 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42102 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42103 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42104 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42105 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42106 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42107 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42108 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42109 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42110 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42111 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42112 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42113 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42114 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42115 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42116 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42117 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42118 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42119 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42120 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42121 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42122 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42123 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42124 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42125 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42126 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42127 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42128 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42129 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42130 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42131 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42132 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42133 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42134 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42135 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42136 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42137 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42138 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42139 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42140 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42141 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42142 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42143 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42144 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42145 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42146 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42147 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42148 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42149 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42150 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42151 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42152 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42153 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42154 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42155 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42156 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42157 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42158 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42159 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42160 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42161 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42162 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42163 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42164 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42165 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42166 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42167 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42168 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42169 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42170 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42171 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42172 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42173 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42174 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42175 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42176 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42177 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42178 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42179 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42180 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42181 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42182 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42183 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42184 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42185 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42186 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42187 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42188 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42189 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42190 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42191 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42192 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42193 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42194 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42195 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42196 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42197 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42198
42199 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42200 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42201 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42202 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42203
42204 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42205 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42206 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42207 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42208 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42209 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42210 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42211 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42212 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42213 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42214 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42215 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42216 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42217 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42218 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42219 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42220 }
42221
wxWidgets (Impactor)