]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reverted the move of wxComboBox styles from wx/defs.h to wx/combobox.h, a lot of...
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafile swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseState swig_types[98]
2565 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2567 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxObject swig_types[104]
2571 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2578 #define SWIGTYPE_p_wxPoint swig_types[112]
2579 #define SWIGTYPE_p_wxPowerEvent swig_types[113]
2580 #define SWIGTYPE_p_wxProcessEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPyApp swig_types[115]
2582 #define SWIGTYPE_p_wxPyArtProvider swig_types[116]
2583 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[117]
2584 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[119]
2586 #define SWIGTYPE_p_wxPyDropSource swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
2588 #define SWIGTYPE_p_wxPyEvent swig_types[122]
2589 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyImageHandler swig_types[124]
2591 #define SWIGTYPE_p_wxPyLog swig_types[125]
2592 #define SWIGTYPE_p_wxPyProcess swig_types[126]
2593 #define SWIGTYPE_p_wxPySizer swig_types[127]
2594 #define SWIGTYPE_p_wxPyTextDataObject swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[129]
2596 #define SWIGTYPE_p_wxPyTimer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTipProvider swig_types[131]
2598 #define SWIGTYPE_p_wxPyValidator swig_types[132]
2599 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[133]
2600 #define SWIGTYPE_p_wxRect swig_types[134]
2601 #define SWIGTYPE_p_wxScrollEvent swig_types[135]
2602 #define SWIGTYPE_p_wxScrollWinEvent swig_types[136]
2603 #define SWIGTYPE_p_wxSetCursorEvent swig_types[137]
2604 #define SWIGTYPE_p_wxShowEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[139]
2606 #define SWIGTYPE_p_wxSize swig_types[140]
2607 #define SWIGTYPE_p_wxSizeEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSizer swig_types[142]
2609 #define SWIGTYPE_p_wxSizerItem swig_types[143]
2610 #define SWIGTYPE_p_wxSound swig_types[144]
2611 #define SWIGTYPE_p_wxStandardPaths swig_types[145]
2612 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[146]
2613 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStopWatch swig_types[148]
2615 #define SWIGTYPE_p_wxString swig_types[149]
2616 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[150]
2617 #define SWIGTYPE_p_wxSystemOptions swig_types[151]
2618 #define SWIGTYPE_p_wxSystemSettings swig_types[152]
2619 #define SWIGTYPE_p_wxTIFFHandler swig_types[153]
2620 #define SWIGTYPE_p_wxTextCtrl swig_types[154]
2621 #define SWIGTYPE_p_wxTextDataObject swig_types[155]
2622 #define SWIGTYPE_p_wxTimeSpan swig_types[156]
2623 #define SWIGTYPE_p_wxTimer swig_types[157]
2624 #define SWIGTYPE_p_wxTimerEvent swig_types[158]
2625 #define SWIGTYPE_p_wxTimerRunner swig_types[159]
2626 #define SWIGTYPE_p_wxTipProvider swig_types[160]
2627 #define SWIGTYPE_p_wxToolTip swig_types[161]
2628 #define SWIGTYPE_p_wxURLDataObject swig_types[162]
2629 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[163]
2630 #define SWIGTYPE_p_wxValidator swig_types[164]
2631 #define SWIGTYPE_p_wxVideoMode swig_types[165]
2632 #define SWIGTYPE_p_wxWindow swig_types[166]
2633 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[167]
2634 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDisabler swig_types[169]
2636 #define SWIGTYPE_p_wxXPMHandler swig_types[170]
2637 static swig_type_info *swig_types[172];
2638 static swig_module_info swig_module = {swig_types, 171, 0, 0, 0, 0};
2639 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2640 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2641
2642 /* -------- TYPES TABLE (END) -------- */
2643
2644 #if (PY_VERSION_HEX <= 0x02000000)
2645 # if !defined(SWIG_PYTHON_CLASSIC)
2646 # error "This python version requires to use swig with the '-classic' option"
2647 # endif
2648 #endif
2649 #if (PY_VERSION_HEX <= 0x02020000)
2650 # error "This python version requires to use swig with the '-nomodern' option"
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodernargs' option"
2654 #endif
2655 #ifndef METH_O
2656 # error "This python version requires to use swig with the '-nofastunpack' option"
2657 #endif
2658
2659 /*-----------------------------------------------
2660 @(target):= _misc_.so
2661 ------------------------------------------------*/
2662 #define SWIG_init init_misc_
2663
2664 #define SWIG_name "_misc_"
2665
2666 #define SWIGVERSION 0x010329
2667
2668
2669 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2670 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2671
2672
2673 #include <stdexcept>
2674
2675
2676 namespace swig {
2677 class PyObject_ptr {
2678 protected:
2679 PyObject *_obj;
2680
2681 public:
2682 PyObject_ptr() :_obj(0)
2683 {
2684 }
2685
2686 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2687 {
2688 Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2692 {
2693 if (initial_ref) Py_XINCREF(_obj);
2694 }
2695
2696 PyObject_ptr & operator=(const PyObject_ptr& item)
2697 {
2698 Py_XINCREF(item._obj);
2699 Py_XDECREF(_obj);
2700 _obj = item._obj;
2701 return *this;
2702 }
2703
2704 ~PyObject_ptr()
2705 {
2706 Py_XDECREF(_obj);
2707 }
2708
2709 operator PyObject *() const
2710 {
2711 return _obj;
2712 }
2713
2714 PyObject *operator->() const
2715 {
2716 return _obj;
2717 }
2718 };
2719 }
2720
2721
2722 namespace swig {
2723 struct PyObject_var : PyObject_ptr {
2724 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2725
2726 PyObject_var & operator = (PyObject* obj)
2727 {
2728 Py_XDECREF(_obj);
2729 _obj = obj;
2730 return *this;
2731 }
2732 };
2733 }
2734
2735
2736 #include "wx/wxPython/wxPython.h"
2737 #include "wx/wxPython/pyclasses.h"
2738 #include "wx/wxPython/pyistream.h"
2739
2740 static const wxString wxPyEmptyString(wxEmptyString);
2741
2742
2743
2744 #define SWIG_From_long PyInt_FromLong
2745
2746
2747 SWIGINTERNINLINE PyObject *
2748 SWIG_From_int (int value)
2749 {
2750 return SWIG_From_long (value);
2751 }
2752
2753
2754 #include <limits.h>
2755 #ifndef LLONG_MIN
2756 # define LLONG_MIN LONG_LONG_MIN
2757 #endif
2758 #ifndef LLONG_MAX
2759 # define LLONG_MAX LONG_LONG_MAX
2760 #endif
2761 #ifndef ULLONG_MAX
2762 # define ULLONG_MAX ULONG_LONG_MAX
2763 #endif
2764
2765
2766 SWIGINTERN int
2767 SWIG_AsVal_long (PyObject* obj, long* val)
2768 {
2769 if (PyNumber_Check(obj)) {
2770 if (val) *val = PyInt_AsLong(obj);
2771 return SWIG_OK;
2772 }
2773 return SWIG_TypeError;
2774 }
2775
2776
2777 SWIGINTERN int
2778 SWIG_AsVal_int (PyObject * obj, int *val)
2779 {
2780 long v;
2781 int res = SWIG_AsVal_long (obj, &v);
2782 if (SWIG_IsOK(res)) {
2783 if ((v < INT_MIN || v > INT_MAX)) {
2784 return SWIG_OverflowError;
2785 } else {
2786 if (val) *val = static_cast< int >(v);
2787 }
2788 }
2789 return res;
2790 }
2791
2792 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2793
2794 #include <wx/stockitem.h>
2795
2796 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2797 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2798 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2799
2800 SWIGINTERN int
2801 SWIG_AsVal_bool (PyObject *obj, bool *val)
2802 {
2803 if (obj == Py_True) {
2804 if (val) *val = true;
2805 return SWIG_OK;
2806 } else if (obj == Py_False) {
2807 if (val) *val = false;
2808 return SWIG_OK;
2809 } else {
2810 long v = 0;
2811 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2812 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2813 return res;
2814 }
2815 }
2816
2817
2818 SWIGINTERN int
2819 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2820 {
2821 long v = 0;
2822 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2823 return SWIG_TypeError;
2824 }
2825 else if (val)
2826 *val = (unsigned long)v;
2827 return SWIG_OK;
2828 }
2829
2830
2831 SWIGINTERNINLINE PyObject*
2832 SWIG_From_unsigned_SS_long (unsigned long value)
2833 {
2834 return (value > LONG_MAX) ?
2835 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2836 }
2837
2838
2839 void* wxGetXDisplay()
2840 {
2841 #ifdef __WXGTK__
2842 return wxGetDisplay();
2843 #else
2844 return NULL;
2845 #endif
2846 }
2847
2848
2849 wxWindow* FindWindowAtPointer() {
2850 wxPoint unused;
2851 return wxFindWindowAtPointer(unused);
2852 }
2853
2854
2855 bool wxThread_IsMain() {
2856 #ifdef WXP_WITH_THREAD
2857 return wxThread::IsMain();
2858 #else
2859 return true;
2860 #endif
2861 }
2862
2863 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2864 delete self;
2865 }
2866
2867 #include <wx/snglinst.h>
2868
2869
2870 #ifdef __WXMSW__
2871 #include <wx/msw/private.h>
2872 #include <wx/dynload.h>
2873 #endif
2874
2875
2876
2877 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2878 #if 0
2879 , int method
2880 #endif
2881 )
2882 {
2883 #ifdef __WXMSW__
2884 #if 0
2885 switch (method)
2886 {
2887 case 1:
2888 // This one only partially works. Appears to be an undocumented
2889 // "standard" convention that not all widgets adhear to. For
2890 // example, for some widgets backgrounds or non-client areas may
2891 // not be painted.
2892 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2893 break;
2894
2895 case 2:
2896 #endif
2897 // This one works much better, nearly all widgets and their
2898 // children are captured correctly[**]. Prior to the big
2899 // background erase changes that Vadim did in 2004-2005 this
2900 // method failed badly on XP with Themes activated, most native
2901 // widgets draw only partially, if at all. Without themes it
2902 // worked just like on Win2k. After those changes this method
2903 // works very well.
2904 //
2905 // ** For example the radio buttons in a wxRadioBox are not its
2906 // children by default, but you can capture it via the panel
2907 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2908 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2909 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2910 PRF_ERASEBKGND | PRF_OWNED );
2911 return true;
2912 #if 0
2913 break;
2914
2915 case 3:
2916 // This one is only defined in the latest SDK and is only
2917 // available on XP. MSDN says it is similar to sending WM_PRINT
2918 // so I expect that it will work similar to the above. Since it
2919 // is avaialble only on XP, it can't be compiled like this and
2920 // will have to be loaded dynamically.
2921 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2922
2923 // fall through
2924
2925 case 4:
2926 // Use PrintWindow if available, or fallback to WM_PRINT
2927 // otherwise. Unfortunately using PrintWindow is even worse than
2928 // WM_PRINT. For most native widgets nothing is drawn to the dc
2929 // at all, with or without Themes.
2930 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2931 static bool s_triedToLoad = false;
2932 static PrintWindow_t pfnPrintWindow = NULL;
2933 if ( !s_triedToLoad )
2934 {
2935
2936 s_triedToLoad = true;
2937 wxDynamicLibrary dllUser32(_T("user32.dll"));
2938 if ( dllUser32.IsLoaded() )
2939 {
2940 wxLogNull nolog; // Don't report errors here
2941 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2942 }
2943 }
2944 if (pfnPrintWindow)
2945 {
2946 //printf("Using PrintWindow\n");
2947 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2948 }
2949 else
2950 {
2951 //printf("Using WM_PRINT\n");
2952 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2953 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2954 PRF_ERASEBKGND | PRF_OWNED );
2955 }
2956 }
2957 #endif // 0
2958 #else
2959 return false;
2960 #endif // __WXMSW__
2961 }
2962
2963
2964
2965 #include <wx/tipdlg.h>
2966
2967
2968 SWIGINTERNINLINE PyObject *
2969 SWIG_From_size_t (size_t value)
2970 {
2971 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2972 }
2973
2974
2975 class wxPyTipProvider : public wxTipProvider {
2976 public:
2977 wxPyTipProvider(size_t currentTip)
2978 : wxTipProvider(currentTip) {}
2979
2980 DEC_PYCALLBACK_STRING__pure(GetTip);
2981 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2982 PYPRIVATE;
2983 };
2984
2985 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2986 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2987
2988
2989 SWIGINTERNINLINE int
2990 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2991 {
2992 unsigned long v;
2993 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2994 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2995 return res;
2996 }
2997
2998
2999 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3000
3001 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3002
3003 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3004 : wxTimer(owner, id)
3005 {
3006 if (owner == NULL)
3007 SetOwner(this);
3008 }
3009
3010
3011 SWIGINTERN swig_type_info*
3012 SWIG_pchar_descriptor()
3013 {
3014 static int init = 0;
3015 static swig_type_info* info = 0;
3016 if (!init) {
3017 info = SWIG_TypeQuery("_p_char");
3018 init = 1;
3019 }
3020 return info;
3021 }
3022
3023
3024 SWIGINTERNINLINE PyObject *
3025 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3026 {
3027 if (carray) {
3028 if (size > INT_MAX) {
3029 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3030 return pchar_descriptor ?
3031 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3032 } else {
3033 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3034 }
3035 } else {
3036 return SWIG_Py_Void();
3037 }
3038 }
3039
3040
3041 SWIGINTERNINLINE PyObject *
3042 SWIG_FromCharPtr(const char *cptr)
3043 {
3044 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3045 }
3046
3047
3048 SWIGINTERN int
3049 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3050 {
3051 unsigned long v;
3052 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3053 if (SWIG_IsOK(res)) {
3054 if ((v > UINT_MAX)) {
3055 return SWIG_OverflowError;
3056 } else {
3057 if (val) *val = static_cast< unsigned int >(v);
3058 }
3059 }
3060 return res;
3061 }
3062
3063 SWIGINTERN wxString wxLog_TimeStamp(){
3064 wxString msg;
3065 wxLog::TimeStamp(&msg);
3066 return msg;
3067 }
3068 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3069 // Make some wrappers that double any % signs so they are 'escaped'
3070 void wxPyLogFatalError(const wxString& msg)
3071 {
3072 wxString m(msg);
3073 m.Replace(wxT("%"), wxT("%%"));
3074 wxLogFatalError(m);
3075 }
3076
3077 void wxPyLogError(const wxString& msg)
3078 {
3079 wxString m(msg);
3080 m.Replace(wxT("%"), wxT("%%"));
3081 wxLogError(m);
3082 }
3083
3084 void wxPyLogWarning(const wxString& msg)
3085 {
3086 wxString m(msg);
3087 m.Replace(wxT("%"), wxT("%%"));
3088 wxLogWarning(m);
3089 }
3090
3091 void wxPyLogMessage(const wxString& msg)
3092 {
3093 wxString m(msg);
3094 m.Replace(wxT("%"), wxT("%%"));
3095 wxLogMessage(m);
3096 }
3097
3098 void wxPyLogInfo(const wxString& msg)
3099 {
3100 wxString m(msg);
3101 m.Replace(wxT("%"), wxT("%%"));
3102 wxLogInfo(m);
3103 }
3104
3105 void wxPyLogDebug(const wxString& msg)
3106 {
3107 wxString m(msg);
3108 m.Replace(wxT("%"), wxT("%%"));
3109 wxLogDebug(m);
3110 }
3111
3112 void wxPyLogVerbose(const wxString& msg)
3113 {
3114 wxString m(msg);
3115 m.Replace(wxT("%"), wxT("%%"));
3116 wxLogVerbose(m);
3117 }
3118
3119 void wxPyLogStatus(const wxString& msg)
3120 {
3121 wxString m(msg);
3122 m.Replace(wxT("%"), wxT("%%"));
3123 wxLogStatus(m);
3124 }
3125
3126 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3127 {
3128 wxString m(msg);
3129 m.Replace(wxT("%"), wxT("%%"));
3130 wxLogStatus(pFrame, m);
3131 }
3132
3133 void wxPyLogSysError(const wxString& msg)
3134 {
3135 wxString m(msg);
3136 m.Replace(wxT("%"), wxT("%%"));
3137 wxLogSysError(m);
3138 }
3139
3140 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3141 {
3142 wxString m(msg);
3143 m.Replace(wxT("%"), wxT("%%"));
3144 wxLogGeneric(level, m);
3145 }
3146
3147 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3148 {
3149 wxString m(msg);
3150 m.Replace(wxT("%"), wxT("%%"));
3151 wxLogTrace(mask, m);
3152 }
3153
3154 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3155 {
3156 wxString m(msg);
3157 m.Replace(wxT("%"), wxT("%%"));
3158 wxLogTrace(mask, m);
3159 }
3160
3161
3162
3163 // A wxLog class that can be derived from in wxPython
3164 class wxPyLog : public wxLog {
3165 public:
3166 wxPyLog() : wxLog() {}
3167
3168 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3169 bool found;
3170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3171 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3172 PyObject* s = wx2PyString(szString);
3173 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3174 Py_DECREF(s);
3175 }
3176 wxPyEndBlockThreads(blocked);
3177 if (! found)
3178 wxLog::DoLog(level, szString, t);
3179 }
3180
3181 virtual void DoLogString(const wxChar *szString, time_t t) {
3182 bool found;
3183 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3184 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3185 PyObject* s = wx2PyString(szString);
3186 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3187 Py_DECREF(s);
3188 }
3189 wxPyEndBlockThreads(blocked);
3190 if (! found)
3191 wxLog::DoLogString(szString, t);
3192 }
3193
3194 DEC_PYCALLBACK_VOID_(Flush);
3195 PYPRIVATE;
3196 };
3197 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3198
3199
3200
3201
3202 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3203
3204
3205 #include <wx/joystick.h>
3206
3207
3208 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3209 // A C++ stub class for wxJoystick for platforms that don't have it.
3210 class wxJoystick : public wxObject {
3211 public:
3212 wxJoystick(int joystick = wxJOYSTICK1) {
3213 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3214 PyErr_SetString(PyExc_NotImplementedError,
3215 "wxJoystick is not available on this platform.");
3216 wxPyEndBlockThreads(blocked);
3217 }
3218 wxPoint GetPosition() { return wxPoint(-1,-1); }
3219 int GetZPosition() { return -1; }
3220 int GetButtonState() { return -1; }
3221 int GetPOVPosition() { return -1; }
3222 int GetPOVCTSPosition() { return -1; }
3223 int GetRudderPosition() { return -1; }
3224 int GetUPosition() { return -1; }
3225 int GetVPosition() { return -1; }
3226 int GetMovementThreshold() { return -1; }
3227 void SetMovementThreshold(int threshold) {}
3228
3229 bool IsOk(void) { return false; }
3230 int GetNumberJoysticks() { return -1; }
3231 int GetManufacturerId() { return -1; }
3232 int GetProductId() { return -1; }
3233 wxString GetProductName() { return wxEmptyString; }
3234 int GetXMin() { return -1; }
3235 int GetYMin() { return -1; }
3236 int GetZMin() { return -1; }
3237 int GetXMax() { return -1; }
3238 int GetYMax() { return -1; }
3239 int GetZMax() { return -1; }
3240 int GetNumberButtons() { return -1; }
3241 int GetNumberAxes() { return -1; }
3242 int GetMaxButtons() { return -1; }
3243 int GetMaxAxes() { return -1; }
3244 int GetPollingMin() { return -1; }
3245 int GetPollingMax() { return -1; }
3246 int GetRudderMin() { return -1; }
3247 int GetRudderMax() { return -1; }
3248 int GetUMin() { return -1; }
3249 int GetUMax() { return -1; }
3250 int GetVMin() { return -1; }
3251 int GetVMax() { return -1; }
3252
3253 bool HasRudder() { return false; }
3254 bool HasZ() { return false; }
3255 bool HasU() { return false; }
3256 bool HasV() { return false; }
3257 bool HasPOV() { return false; }
3258 bool HasPOV4Dir() { return false; }
3259 bool HasPOVCTS() { return false; }
3260
3261 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3262 bool ReleaseCapture() { return false; }
3263 };
3264 #endif
3265
3266
3267 #include <wx/sound.h>
3268
3269
3270 #if !wxUSE_SOUND
3271 // A C++ stub class for wxWave for platforms that don't have it.
3272 class wxSound : public wxObject
3273 {
3274 public:
3275 wxSound() {
3276 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3277 PyErr_SetString(PyExc_NotImplementedError,
3278 "wxSound is not available on this platform.");
3279 wxPyEndBlockThreads(blocked);
3280 }
3281 wxSound(const wxString&/*, bool*/) {
3282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3283 PyErr_SetString(PyExc_NotImplementedError,
3284 "wxSound is not available on this platform.");
3285 wxPyEndBlockThreads(blocked);
3286 }
3287 wxSound(int, const wxByte*) {
3288 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3289 PyErr_SetString(PyExc_NotImplementedError,
3290 "wxSound is not available on this platform.");
3291 wxPyEndBlockThreads(blocked);
3292 }
3293
3294 ~wxSound() {};
3295
3296 bool Create(const wxString&/*, bool*/) { return false; }
3297 bool Create(int, const wxByte*) { return false; };
3298 bool IsOk() { return false; };
3299 bool Play(unsigned) const { return false; }
3300 static bool Play(const wxString&, unsigned) { return false; }
3301 static void Stop() {}
3302 };
3303
3304 #endif
3305
3306 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3307 if (fileName.Length() == 0)
3308 return new wxSound;
3309 else
3310 return new wxSound(fileName);
3311 }
3312 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3313 unsigned char* buffer; int size;
3314 wxSound *sound = NULL;
3315
3316 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3317 if (!PyArg_Parse(data, "t#", &buffer, &size))
3318 goto done;
3319 sound = new wxSound(size, buffer);
3320 done:
3321 wxPyEndBlockThreads(blocked);
3322 return sound;
3323 }
3324 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3325 #ifndef __WXMAC__
3326 unsigned char* buffer;
3327 int size;
3328 bool rv = false;
3329
3330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3331 if (!PyArg_Parse(data, "t#", &buffer, &size))
3332 goto done;
3333 rv = self->Create(size, buffer);
3334 done:
3335 wxPyEndBlockThreads(blocked);
3336 return rv;
3337 #else
3338 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3339 PyErr_SetString(PyExc_NotImplementedError,
3340 "Create from data is not available on this platform.");
3341 wxPyEndBlockThreads(blocked);
3342 return false;
3343 #endif
3344 }
3345
3346 #include <wx/mimetype.h>
3347
3348 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3349 wxString str;
3350 if (self->GetMimeType(&str))
3351 return wx2PyString(str);
3352 else
3353 RETURN_NONE();
3354 }
3355 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3356 wxArrayString arr;
3357 if (self->GetMimeTypes(arr))
3358 return wxArrayString2PyList_helper(arr);
3359 else
3360 RETURN_NONE();
3361 }
3362 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3363 wxArrayString arr;
3364 if (self->GetExtensions(arr))
3365 return wxArrayString2PyList_helper(arr);
3366 else
3367 RETURN_NONE();
3368 }
3369 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3370 wxIconLocation loc;
3371 if (self->GetIcon(&loc))
3372 return new wxIcon(loc);
3373 else
3374 return NULL;
3375 }
3376 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3377 wxIconLocation loc;
3378 if (self->GetIcon(&loc)) {
3379 wxString iconFile = loc.GetFileName();
3380 int iconIndex = -1;
3381
3382 iconIndex = loc.GetIndex();
3383
3384 // Make a tuple and put the values in it
3385 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3386 PyObject* tuple = PyTuple_New(3);
3387 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3388 wxT("wxIcon"), true));
3389 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3390 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3391 wxPyEndBlockThreads(blocked);
3392 return tuple;
3393 }
3394 else
3395 RETURN_NONE();
3396 }
3397 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3398 wxString str;
3399 if (self->GetDescription(&str))
3400 return wx2PyString(str);
3401 else
3402 RETURN_NONE();
3403 }
3404 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3405 wxString str;
3406 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3407 return wx2PyString(str);
3408 else
3409 RETURN_NONE();
3410 }
3411 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3412 wxString str;
3413 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3414 return wx2PyString(str);
3415 else
3416 RETURN_NONE();
3417 }
3418 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3419 wxArrayString verbs;
3420 wxArrayString commands;
3421 if (self->GetAllCommands(&verbs, &commands,
3422 wxFileType::MessageParameters(filename, mimetype))) {
3423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3424 PyObject* tuple = PyTuple_New(2);
3425 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3426 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3427 wxPyEndBlockThreads(blocked);
3428 return tuple;
3429 }
3430 else
3431 RETURN_NONE();
3432 }
3433 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3434 return wxFileType::ExpandCommand(command,
3435 wxFileType::MessageParameters(filename, mimetype));
3436 }
3437 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3438 wxArrayString arr;
3439 self->EnumAllFileTypes(arr);
3440 return wxArrayString2PyList_helper(arr);
3441 }
3442
3443 #include <wx/artprov.h>
3444
3445 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3446 static const wxString wxPyART_MENU(wxART_MENU);
3447 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3448 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3449 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3450 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3451 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3452 static const wxString wxPyART_OTHER(wxART_OTHER);
3453 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3454 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3455 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3456 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3457 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3458 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3459 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3460 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3461 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3462 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3463 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3464 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3465 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3466 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3467 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3468 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3469 static const wxString wxPyART_PRINT(wxART_PRINT);
3470 static const wxString wxPyART_HELP(wxART_HELP);
3471 static const wxString wxPyART_TIP(wxART_TIP);
3472 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3473 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3474 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3475 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3476 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3477 static const wxString wxPyART_CDROM(wxART_CDROM);
3478 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3479 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3480 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3481 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3482 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3483 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3484 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3485 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3486 static const wxString wxPyART_ERROR(wxART_ERROR);
3487 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3488 static const wxString wxPyART_WARNING(wxART_WARNING);
3489 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3490 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3491 static const wxString wxPyART_COPY(wxART_COPY);
3492 static const wxString wxPyART_CUT(wxART_CUT);
3493 static const wxString wxPyART_PASTE(wxART_PASTE);
3494 static const wxString wxPyART_DELETE(wxART_DELETE);
3495 static const wxString wxPyART_NEW(wxART_NEW);
3496 static const wxString wxPyART_UNDO(wxART_UNDO);
3497 static const wxString wxPyART_REDO(wxART_REDO);
3498 static const wxString wxPyART_QUIT(wxART_QUIT);
3499 static const wxString wxPyART_FIND(wxART_FIND);
3500 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3501 // Python aware wxArtProvider
3502 class wxPyArtProvider : public wxArtProvider {
3503 public:
3504
3505 virtual wxBitmap CreateBitmap(const wxArtID& id,
3506 const wxArtClient& client,
3507 const wxSize& size) {
3508 wxBitmap rval = wxNullBitmap;
3509 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3510 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3511 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3512 PyObject* ro;
3513 wxBitmap* ptr;
3514 PyObject* s1, *s2;
3515 s1 = wx2PyString(id);
3516 s2 = wx2PyString(client);
3517 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3518 Py_DECREF(so);
3519 Py_DECREF(s1);
3520 Py_DECREF(s2);
3521 if (ro) {
3522 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3523 rval = *ptr;
3524 Py_DECREF(ro);
3525 }
3526 }
3527 wxPyEndBlockThreads(blocked);
3528 return rval;
3529 }
3530
3531 PYPRIVATE;
3532 };
3533
3534 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3535
3536
3537
3538 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3539 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3540 PyObject* ret = PyTuple_New(3);
3541 if (ret) {
3542 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3543 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3544 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3545 }
3546 wxPyEndBlockThreads(blocked);
3547 return ret;
3548 }
3549
3550 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3551 bool cont;
3552 long index = 0;
3553 wxString value;
3554
3555 cont = self->GetFirstGroup(value, index);
3556 return __EnumerationHelper(cont, value, index);
3557 }
3558 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3559 bool cont;
3560 wxString value;
3561
3562 cont = self->GetNextGroup(value, index);
3563 return __EnumerationHelper(cont, value, index);
3564 }
3565 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3566 bool cont;
3567 long index = 0;
3568 wxString value;
3569
3570 cont = self->GetFirstEntry(value, index);
3571 return __EnumerationHelper(cont, value, index);
3572 }
3573 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3574 bool cont;
3575 wxString value;
3576
3577 cont = self->GetNextEntry(value, index);
3578 return __EnumerationHelper(cont, value, index);
3579 }
3580 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3581 long rv;
3582 self->Read(key, &rv, defaultVal);
3583 return rv;
3584 }
3585
3586 SWIGINTERN int
3587 SWIG_AsVal_double (PyObject *obj, double* val)
3588 {
3589 if (PyNumber_Check(obj)) {
3590 if (val) *val = PyFloat_AsDouble(obj);
3591 return SWIG_OK;
3592 }
3593 return SWIG_TypeError;
3594 }
3595
3596 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3597 double rv;
3598 self->Read(key, &rv, defaultVal);
3599 return rv;
3600 }
3601
3602 #define SWIG_From_double PyFloat_FromDouble
3603
3604 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3605 bool rv;
3606 self->Read(key, &rv, defaultVal);
3607 return rv;
3608 }
3609
3610 #include <wx/datetime.h>
3611
3612 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3613 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3614
3615 #define LOCAL_TZ wxDateTime::Local
3616
3617 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3618 wxString am;
3619 wxString pm;
3620 wxDateTime::GetAmPmStrings(&am, &pm);
3621 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3622 PyObject* tup = PyTuple_New(2);
3623 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3624 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3625 wxPyEndBlockThreads(blocked);
3626 return tup;
3627 }
3628
3629 SWIGINTERNINLINE PyObject *
3630 SWIG_From_unsigned_SS_int (unsigned int value)
3631 {
3632 return SWIG_From_unsigned_SS_long (value);
3633 }
3634
3635 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3636 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3637 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3638 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3639 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3640 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3641 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3642 return (*self < *other);
3643 }
3644 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3645 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3646 return (*self <= *other);
3647 }
3648 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3649 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3650 return (*self > *other);
3651 }
3652 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3653 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3654 return (*self >= *other);
3655 }
3656 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3658 return (*self == *other);
3659 }
3660 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3662 return (*self != *other);
3663 }
3664 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3665 const wxChar* rv;
3666 const wxChar* _date = date;
3667 rv = self->ParseRfc822Date(_date);
3668 if (rv == NULL) return -1;
3669 return rv - _date;
3670 }
3671 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3672 const wxChar* rv;
3673 const wxChar* _date = date;
3674 rv = self->ParseFormat(_date, format, dateDef);
3675 if (rv == NULL) return -1;
3676 return rv - _date;
3677 }
3678 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3679 const wxChar* rv;
3680 const wxChar* _datetime = datetime;
3681 rv = self->ParseDateTime(_datetime);
3682 if (rv == NULL) return -1;
3683 return rv - _datetime;
3684 }
3685 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3686 const wxChar* rv;
3687 const wxChar* _date = date;
3688 rv = self->ParseDate(_date);
3689 if (rv == NULL) return -1;
3690 return rv - _date;
3691 }
3692 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3693 const wxChar* rv;
3694 const wxChar* _time = time;
3695 rv = self->ParseTime(_time);
3696 if (rv == NULL) return -1;
3697 return rv - _time;
3698 }
3699 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3700 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3701 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3703 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3704 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3705 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3706 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3707 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3709 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3710 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3711 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3712 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3713 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3714 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3715
3716 #include <wx/dataobj.h>
3717
3718 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3719 size_t count = self->GetFormatCount(dir);
3720 wxDataFormat* formats = new wxDataFormat[count];
3721 self->GetAllFormats(formats, dir);
3722
3723 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3724 PyObject* list = PyList_New(count);
3725 for (size_t i=0; i<count; i++) {
3726 wxDataFormat* format = new wxDataFormat(formats[i]);
3727 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3728 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3729 }
3730 wxPyEndBlockThreads(blocked);
3731 delete [] formats;
3732 return list;
3733 }
3734 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3735 PyObject* rval = NULL;
3736 size_t size = self->GetDataSize(format);
3737 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3738 if (size) {
3739 char* buf = new char[size];
3740 if (self->GetDataHere(format, buf))
3741 rval = PyString_FromStringAndSize(buf, size);
3742 delete [] buf;
3743 }
3744 if (! rval) {
3745 rval = Py_None;
3746 Py_INCREF(rval);
3747 }
3748 wxPyEndBlockThreads(blocked);
3749 return rval;
3750 }
3751 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3752 bool rval;
3753 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3754 if (PyString_Check(data)) {
3755 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3756 }
3757 else {
3758 // raise a TypeError if not a string
3759 PyErr_SetString(PyExc_TypeError, "String expected.");
3760 rval = false;
3761 }
3762 wxPyEndBlockThreads(blocked);
3763 return rval;
3764 }
3765 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3766 PyObject* rval = NULL;
3767 size_t size = self->GetDataSize();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 if (size) {
3770 char* buf = new char[size];
3771 if (self->GetDataHere(buf))
3772 rval = PyString_FromStringAndSize(buf, size);
3773 delete [] buf;
3774 }
3775 if (! rval) {
3776 rval = Py_None;
3777 Py_INCREF(rval);
3778 }
3779 wxPyEndBlockThreads(blocked);
3780 return rval;
3781 }
3782 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3783 bool rval;
3784 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3785 if (PyString_Check(data)) {
3786 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3787 }
3788 else {
3789 // raise a TypeError if not a string
3790 PyErr_SetString(PyExc_TypeError, "String expected.");
3791 rval = false;
3792 }
3793 wxPyEndBlockThreads(blocked);
3794 return rval;
3795 }
3796 // Create a new class for wxPython to use
3797 class wxPyDataObjectSimple : public wxDataObjectSimple {
3798 public:
3799 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3800 : wxDataObjectSimple(format) {}
3801
3802 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3803 bool GetDataHere(void *buf) const;
3804 bool SetData(size_t len, const void *buf);
3805 PYPRIVATE;
3806 };
3807
3808 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3809
3810 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3811 // We need to get the data for this object and write it to buf. I think
3812 // the best way to do this for wxPython is to have the Python method
3813 // return either a string or None and then act appropriately with the
3814 // C++ version.
3815
3816 bool rval = false;
3817 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3818 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3819 PyObject* ro;
3820 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3821 if (ro) {
3822 rval = (ro != Py_None && PyString_Check(ro));
3823 if (rval)
3824 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3825 Py_DECREF(ro);
3826 }
3827 }
3828 wxPyEndBlockThreads(blocked);
3829 return rval;
3830 }
3831
3832 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3833 // For this one we simply need to make a string from buf and len
3834 // and send it to the Python method.
3835 bool rval = false;
3836 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3837 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3838 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3839 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3840 Py_DECREF(data);
3841 }
3842 wxPyEndBlockThreads(blocked);
3843 return rval;
3844 }
3845
3846 // Create a new class for wxPython to use
3847 class wxPyTextDataObject : public wxTextDataObject {
3848 public:
3849 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3850 : wxTextDataObject(text) {}
3851
3852 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3853 DEC_PYCALLBACK_STRING__const(GetText);
3854 DEC_PYCALLBACK__STRING(SetText);
3855 PYPRIVATE;
3856 };
3857
3858 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3859 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3860 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3861
3862
3863 // Create a new class for wxPython to use
3864 class wxPyBitmapDataObject : public wxBitmapDataObject {
3865 public:
3866 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3867 : wxBitmapDataObject(bitmap) {}
3868
3869 wxBitmap GetBitmap() const;
3870 void SetBitmap(const wxBitmap& bitmap);
3871 PYPRIVATE;
3872 };
3873
3874 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3875 wxBitmap* rval = &wxNullBitmap;
3876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3877 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3878 PyObject* ro;
3879 wxBitmap* ptr;
3880 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3881 if (ro) {
3882 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3883 rval = ptr;
3884 Py_DECREF(ro);
3885 }
3886 }
3887 wxPyEndBlockThreads(blocked);
3888 return *rval;
3889 }
3890
3891 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3892 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3893 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3894 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3895 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3896 Py_DECREF(bo);
3897 }
3898 wxPyEndBlockThreads(blocked);
3899 }
3900
3901 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3902 return new wxCustomDataObject(wxDataFormat(formatName));
3903 }
3904 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3905 bool rval;
3906 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3907 if (PyString_Check(data)) {
3908 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3909 }
3910 else {
3911 // raise a TypeError if not a string
3912 PyErr_SetString(PyExc_TypeError, "String expected.");
3913 rval = false;
3914 }
3915 wxPyEndBlockThreads(blocked);
3916 return rval;
3917 }
3918 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3919 PyObject* obj;
3920 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3921 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3922 wxPyEndBlockThreads(blocked);
3923 return obj;
3924 }
3925
3926 #include <wx/metafile.h>
3927
3928
3929 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3930
3931
3932 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3933 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3934 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3935 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3936 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3937
3938
3939 class wxPyTextDropTarget : public wxTextDropTarget {
3940 public:
3941 wxPyTextDropTarget() {}
3942
3943 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3944
3945 DEC_PYCALLBACK__(OnLeave);
3946 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3947 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3948 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3949 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3950
3951 PYPRIVATE;
3952 };
3953
3954 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3955 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3956 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3957 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3958 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3959 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3960
3961
3962
3963 class wxPyFileDropTarget : public wxFileDropTarget {
3964 public:
3965 wxPyFileDropTarget() {}
3966
3967 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3968
3969 DEC_PYCALLBACK__(OnLeave);
3970 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3971 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3972 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3973 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3974
3975 PYPRIVATE;
3976 };
3977
3978 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3979 const wxArrayString& filenames) {
3980 bool rval = false;
3981 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3982 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3983 PyObject* list = wxArrayString2PyList_helper(filenames);
3984 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3985 Py_DECREF(list);
3986 }
3987 wxPyEndBlockThreads(blocked);
3988 return rval;
3989 }
3990
3991
3992
3993 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3994 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3995 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3996 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3997 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3998
3999
4000
4001
4002 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4003
4004 #include <wx/display.h>
4005
4006 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4007 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4008
4009 #if !wxUSE_DISPLAY
4010 const wxVideoMode wxDefaultVideoMode;
4011 #endif
4012
4013 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4014 #if wxUSE_DISPLAY
4015 PyObject* pyList = NULL;
4016 wxArrayVideoModes arr = self->GetModes(mode);
4017 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4018 pyList = PyList_New(0);
4019 for (size_t i=0; i < arr.GetCount(); i++)
4020 {
4021 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4022 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4023 PyList_Append(pyList, pyObj);
4024 Py_DECREF(pyObj);
4025 }
4026 wxPyEndBlockThreads(blocked);
4027 return pyList;
4028 #else
4029 wxPyRaiseNotImplemented();
4030 return NULL;
4031 #endif
4032 }
4033 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4034 #if wxUSE_DISPLAY
4035 return self->GetCurrentMode();
4036 #else
4037 wxPyRaiseNotImplemented();
4038 return wxDefaultVideoMode;
4039 #endif
4040 }
4041 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4042 #if wxUSE_DISPLAY
4043 return self->ChangeMode(mode);
4044 #else
4045 wxPyRaiseNotImplemented();
4046 return false;
4047 #endif
4048 }
4049 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4050 #if wxUSE_DISPLAY
4051 self->ResetMode();
4052 #else
4053 wxPyRaiseNotImplemented();
4054 #endif
4055 }
4056
4057 #include <wx/stdpaths.h>
4058
4059 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4060 return (wxStandardPaths*) &wxStandardPaths::Get();
4061 }
4062 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4063 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4064
4065 #ifndef wxHAS_POWER_EVENTS
4066 // Dummy class and other definitions for platforms that don't have them
4067
4068 // See wxPython_int.h for wxPowerEvent
4069
4070 enum {
4071 wxEVT_POWER_SUSPENDING,
4072 wxEVT_POWER_SUSPENDED,
4073 wxEVT_POWER_SUSPEND_CANCEL,
4074 wxEVT_POWER_RESUME,
4075 };
4076
4077 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4078 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4079
4080 #endif
4081
4082 #ifdef __cplusplus
4083 extern "C" {
4084 #endif
4085 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4086 PyObject *resultobj = 0;
4087 wxSystemColour arg1 ;
4088 wxColour result;
4089 int val1 ;
4090 int ecode1 = 0 ;
4091 PyObject * obj0 = 0 ;
4092 char * kwnames[] = {
4093 (char *) "index", NULL
4094 };
4095
4096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4097 ecode1 = SWIG_AsVal_int(obj0, &val1);
4098 if (!SWIG_IsOK(ecode1)) {
4099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4100 }
4101 arg1 = static_cast< wxSystemColour >(val1);
4102 {
4103 if (!wxPyCheckForApp()) SWIG_fail;
4104 PyThreadState* __tstate = wxPyBeginAllowThreads();
4105 result = wxSystemSettings::GetColour(arg1);
4106 wxPyEndAllowThreads(__tstate);
4107 if (PyErr_Occurred()) SWIG_fail;
4108 }
4109 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4110 return resultobj;
4111 fail:
4112 return NULL;
4113 }
4114
4115
4116 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4117 PyObject *resultobj = 0;
4118 wxSystemFont arg1 ;
4119 wxFont result;
4120 int val1 ;
4121 int ecode1 = 0 ;
4122 PyObject * obj0 = 0 ;
4123 char * kwnames[] = {
4124 (char *) "index", NULL
4125 };
4126
4127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4128 ecode1 = SWIG_AsVal_int(obj0, &val1);
4129 if (!SWIG_IsOK(ecode1)) {
4130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4131 }
4132 arg1 = static_cast< wxSystemFont >(val1);
4133 {
4134 if (!wxPyCheckForApp()) SWIG_fail;
4135 PyThreadState* __tstate = wxPyBeginAllowThreads();
4136 result = wxSystemSettings::GetFont(arg1);
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4141 return resultobj;
4142 fail:
4143 return NULL;
4144 }
4145
4146
4147 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4148 PyObject *resultobj = 0;
4149 wxSystemMetric arg1 ;
4150 wxWindow *arg2 = (wxWindow *) NULL ;
4151 int result;
4152 int val1 ;
4153 int ecode1 = 0 ;
4154 void *argp2 = 0 ;
4155 int res2 = 0 ;
4156 PyObject * obj0 = 0 ;
4157 PyObject * obj1 = 0 ;
4158 char * kwnames[] = {
4159 (char *) "index",(char *) "win", NULL
4160 };
4161
4162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4163 ecode1 = SWIG_AsVal_int(obj0, &val1);
4164 if (!SWIG_IsOK(ecode1)) {
4165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4166 }
4167 arg1 = static_cast< wxSystemMetric >(val1);
4168 if (obj1) {
4169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4170 if (!SWIG_IsOK(res2)) {
4171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4172 }
4173 arg2 = reinterpret_cast< wxWindow * >(argp2);
4174 }
4175 {
4176 if (!wxPyCheckForApp()) SWIG_fail;
4177 PyThreadState* __tstate = wxPyBeginAllowThreads();
4178 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4179 wxPyEndAllowThreads(__tstate);
4180 if (PyErr_Occurred()) SWIG_fail;
4181 }
4182 resultobj = SWIG_From_int(static_cast< int >(result));
4183 return resultobj;
4184 fail:
4185 return NULL;
4186 }
4187
4188
4189 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4190 PyObject *resultobj = 0;
4191 wxSystemFeature arg1 ;
4192 bool result;
4193 int val1 ;
4194 int ecode1 = 0 ;
4195 PyObject * obj0 = 0 ;
4196 char * kwnames[] = {
4197 (char *) "index", NULL
4198 };
4199
4200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4201 ecode1 = SWIG_AsVal_int(obj0, &val1);
4202 if (!SWIG_IsOK(ecode1)) {
4203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4204 }
4205 arg1 = static_cast< wxSystemFeature >(val1);
4206 {
4207 if (!wxPyCheckForApp()) SWIG_fail;
4208 PyThreadState* __tstate = wxPyBeginAllowThreads();
4209 result = (bool)wxSystemSettings::HasFeature(arg1);
4210 wxPyEndAllowThreads(__tstate);
4211 if (PyErr_Occurred()) SWIG_fail;
4212 }
4213 {
4214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4215 }
4216 return resultobj;
4217 fail:
4218 return NULL;
4219 }
4220
4221
4222 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4223 PyObject *resultobj = 0;
4224 wxSystemScreenType result;
4225
4226 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4227 {
4228 if (!wxPyCheckForApp()) SWIG_fail;
4229 PyThreadState* __tstate = wxPyBeginAllowThreads();
4230 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4231 wxPyEndAllowThreads(__tstate);
4232 if (PyErr_Occurred()) SWIG_fail;
4233 }
4234 resultobj = SWIG_From_int(static_cast< int >(result));
4235 return resultobj;
4236 fail:
4237 return NULL;
4238 }
4239
4240
4241 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4242 PyObject *resultobj = 0;
4243 wxSystemScreenType arg1 ;
4244 int val1 ;
4245 int ecode1 = 0 ;
4246 PyObject * obj0 = 0 ;
4247 char * kwnames[] = {
4248 (char *) "screen", NULL
4249 };
4250
4251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4252 ecode1 = SWIG_AsVal_int(obj0, &val1);
4253 if (!SWIG_IsOK(ecode1)) {
4254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4255 }
4256 arg1 = static_cast< wxSystemScreenType >(val1);
4257 {
4258 if (!wxPyCheckForApp()) SWIG_fail;
4259 PyThreadState* __tstate = wxPyBeginAllowThreads();
4260 wxSystemSettings::SetScreenType(arg1);
4261 wxPyEndAllowThreads(__tstate);
4262 if (PyErr_Occurred()) SWIG_fail;
4263 }
4264 resultobj = SWIG_Py_Void();
4265 return resultobj;
4266 fail:
4267 return NULL;
4268 }
4269
4270
4271 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4272 PyObject *obj;
4273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4274 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4275 return SWIG_Py_Void();
4276 }
4277
4278 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4279 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4280 return 1;
4281 }
4282
4283
4284 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4285 PyObject *pyobj = 0;
4286
4287 {
4288 #if wxUSE_UNICODE
4289 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4290 #else
4291 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4292 #endif
4293 }
4294 return pyobj;
4295 }
4296
4297
4298 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4299 PyObject *resultobj = 0;
4300 wxSystemOptions *result = 0 ;
4301
4302 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4303 {
4304 PyThreadState* __tstate = wxPyBeginAllowThreads();
4305 result = (wxSystemOptions *)new wxSystemOptions();
4306 wxPyEndAllowThreads(__tstate);
4307 if (PyErr_Occurred()) SWIG_fail;
4308 }
4309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4310 return resultobj;
4311 fail:
4312 return NULL;
4313 }
4314
4315
4316 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4317 PyObject *resultobj = 0;
4318 wxString *arg1 = 0 ;
4319 wxString *arg2 = 0 ;
4320 bool temp1 = false ;
4321 bool temp2 = false ;
4322 PyObject * obj0 = 0 ;
4323 PyObject * obj1 = 0 ;
4324 char * kwnames[] = {
4325 (char *) "name",(char *) "value", NULL
4326 };
4327
4328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4329 {
4330 arg1 = wxString_in_helper(obj0);
4331 if (arg1 == NULL) SWIG_fail;
4332 temp1 = true;
4333 }
4334 {
4335 arg2 = wxString_in_helper(obj1);
4336 if (arg2 == NULL) SWIG_fail;
4337 temp2 = true;
4338 }
4339 {
4340 PyThreadState* __tstate = wxPyBeginAllowThreads();
4341 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4342 wxPyEndAllowThreads(__tstate);
4343 if (PyErr_Occurred()) SWIG_fail;
4344 }
4345 resultobj = SWIG_Py_Void();
4346 {
4347 if (temp1)
4348 delete arg1;
4349 }
4350 {
4351 if (temp2)
4352 delete arg2;
4353 }
4354 return resultobj;
4355 fail:
4356 {
4357 if (temp1)
4358 delete arg1;
4359 }
4360 {
4361 if (temp2)
4362 delete arg2;
4363 }
4364 return NULL;
4365 }
4366
4367
4368 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj = 0;
4370 wxString *arg1 = 0 ;
4371 int arg2 ;
4372 bool temp1 = false ;
4373 int val2 ;
4374 int ecode2 = 0 ;
4375 PyObject * obj0 = 0 ;
4376 PyObject * obj1 = 0 ;
4377 char * kwnames[] = {
4378 (char *) "name",(char *) "value", NULL
4379 };
4380
4381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4382 {
4383 arg1 = wxString_in_helper(obj0);
4384 if (arg1 == NULL) SWIG_fail;
4385 temp1 = true;
4386 }
4387 ecode2 = SWIG_AsVal_int(obj1, &val2);
4388 if (!SWIG_IsOK(ecode2)) {
4389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4390 }
4391 arg2 = static_cast< int >(val2);
4392 {
4393 PyThreadState* __tstate = wxPyBeginAllowThreads();
4394 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4395 wxPyEndAllowThreads(__tstate);
4396 if (PyErr_Occurred()) SWIG_fail;
4397 }
4398 resultobj = SWIG_Py_Void();
4399 {
4400 if (temp1)
4401 delete arg1;
4402 }
4403 return resultobj;
4404 fail:
4405 {
4406 if (temp1)
4407 delete arg1;
4408 }
4409 return NULL;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4414 PyObject *resultobj = 0;
4415 wxString *arg1 = 0 ;
4416 wxString result;
4417 bool temp1 = false ;
4418 PyObject * obj0 = 0 ;
4419 char * kwnames[] = {
4420 (char *) "name", NULL
4421 };
4422
4423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4424 {
4425 arg1 = wxString_in_helper(obj0);
4426 if (arg1 == NULL) SWIG_fail;
4427 temp1 = true;
4428 }
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 {
4436 #if wxUSE_UNICODE
4437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4438 #else
4439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4440 #endif
4441 }
4442 {
4443 if (temp1)
4444 delete arg1;
4445 }
4446 return resultobj;
4447 fail:
4448 {
4449 if (temp1)
4450 delete arg1;
4451 }
4452 return NULL;
4453 }
4454
4455
4456 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4457 PyObject *resultobj = 0;
4458 wxString *arg1 = 0 ;
4459 int result;
4460 bool temp1 = false ;
4461 PyObject * obj0 = 0 ;
4462 char * kwnames[] = {
4463 (char *) "name", NULL
4464 };
4465
4466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4467 {
4468 arg1 = wxString_in_helper(obj0);
4469 if (arg1 == NULL) SWIG_fail;
4470 temp1 = true;
4471 }
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 resultobj = SWIG_From_int(static_cast< int >(result));
4479 {
4480 if (temp1)
4481 delete arg1;
4482 }
4483 return resultobj;
4484 fail:
4485 {
4486 if (temp1)
4487 delete arg1;
4488 }
4489 return NULL;
4490 }
4491
4492
4493 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4494 PyObject *resultobj = 0;
4495 wxString *arg1 = 0 ;
4496 bool result;
4497 bool temp1 = false ;
4498 PyObject * obj0 = 0 ;
4499 char * kwnames[] = {
4500 (char *) "name", NULL
4501 };
4502
4503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4504 {
4505 arg1 = wxString_in_helper(obj0);
4506 if (arg1 == NULL) SWIG_fail;
4507 temp1 = true;
4508 }
4509 {
4510 PyThreadState* __tstate = wxPyBeginAllowThreads();
4511 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4512 wxPyEndAllowThreads(__tstate);
4513 if (PyErr_Occurred()) SWIG_fail;
4514 }
4515 {
4516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4517 }
4518 {
4519 if (temp1)
4520 delete arg1;
4521 }
4522 return resultobj;
4523 fail:
4524 {
4525 if (temp1)
4526 delete arg1;
4527 }
4528 return NULL;
4529 }
4530
4531
4532 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4533 PyObject *resultobj = 0;
4534 wxString *arg1 = 0 ;
4535 bool result;
4536 bool temp1 = false ;
4537 PyObject * obj0 = 0 ;
4538 char * kwnames[] = {
4539 (char *) "name", NULL
4540 };
4541
4542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4543 {
4544 arg1 = wxString_in_helper(obj0);
4545 if (arg1 == NULL) SWIG_fail;
4546 temp1 = true;
4547 }
4548 {
4549 PyThreadState* __tstate = wxPyBeginAllowThreads();
4550 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4551 wxPyEndAllowThreads(__tstate);
4552 if (PyErr_Occurred()) SWIG_fail;
4553 }
4554 {
4555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4556 }
4557 {
4558 if (temp1)
4559 delete arg1;
4560 }
4561 return resultobj;
4562 fail:
4563 {
4564 if (temp1)
4565 delete arg1;
4566 }
4567 return NULL;
4568 }
4569
4570
4571 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4572 PyObject *obj;
4573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4574 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4575 return SWIG_Py_Void();
4576 }
4577
4578 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4579 return SWIG_Python_InitShadowInstance(args);
4580 }
4581
4582 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4583 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4584 return 1;
4585 }
4586
4587
4588 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4589 PyObject *pyobj = 0;
4590
4591 {
4592 #if wxUSE_UNICODE
4593 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4594 #else
4595 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4596 #endif
4597 }
4598 return pyobj;
4599 }
4600
4601
4602 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4603 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4604 return 1;
4605 }
4606
4607
4608 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4609 PyObject *pyobj = 0;
4610
4611 {
4612 #if wxUSE_UNICODE
4613 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4614 #else
4615 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4616 #endif
4617 }
4618 return pyobj;
4619 }
4620
4621
4622 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4623 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4624 return 1;
4625 }
4626
4627
4628 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4629 PyObject *pyobj = 0;
4630
4631 {
4632 #if wxUSE_UNICODE
4633 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4634 #else
4635 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4636 #endif
4637 }
4638 return pyobj;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4643 PyObject *resultobj = 0;
4644 long result;
4645
4646 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4647 {
4648 PyThreadState* __tstate = wxPyBeginAllowThreads();
4649 result = (long)wxNewId();
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 resultobj = SWIG_From_long(static_cast< long >(result));
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = 0;
4662 long arg1 ;
4663 long val1 ;
4664 int ecode1 = 0 ;
4665 PyObject * obj0 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "id", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4671 ecode1 = SWIG_AsVal_long(obj0, &val1);
4672 if (!SWIG_IsOK(ecode1)) {
4673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4674 }
4675 arg1 = static_cast< long >(val1);
4676 {
4677 PyThreadState* __tstate = wxPyBeginAllowThreads();
4678 wxRegisterId(arg1);
4679 wxPyEndAllowThreads(__tstate);
4680 if (PyErr_Occurred()) SWIG_fail;
4681 }
4682 resultobj = SWIG_Py_Void();
4683 return resultobj;
4684 fail:
4685 return NULL;
4686 }
4687
4688
4689 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4690 PyObject *resultobj = 0;
4691 long result;
4692
4693 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4694 {
4695 PyThreadState* __tstate = wxPyBeginAllowThreads();
4696 result = (long)wxGetCurrentId();
4697 wxPyEndAllowThreads(__tstate);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 resultobj = SWIG_From_long(static_cast< long >(result));
4701 return resultobj;
4702 fail:
4703 return NULL;
4704 }
4705
4706
4707 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4708 PyObject *resultobj = 0;
4709 int arg1 ;
4710 bool result;
4711 int val1 ;
4712 int ecode1 = 0 ;
4713 PyObject * obj0 = 0 ;
4714 char * kwnames[] = {
4715 (char *) "id", NULL
4716 };
4717
4718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4719 ecode1 = SWIG_AsVal_int(obj0, &val1);
4720 if (!SWIG_IsOK(ecode1)) {
4721 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4722 }
4723 arg1 = static_cast< int >(val1);
4724 {
4725 PyThreadState* __tstate = wxPyBeginAllowThreads();
4726 result = (bool)wxIsStockID(arg1);
4727 wxPyEndAllowThreads(__tstate);
4728 if (PyErr_Occurred()) SWIG_fail;
4729 }
4730 {
4731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4732 }
4733 return resultobj;
4734 fail:
4735 return NULL;
4736 }
4737
4738
4739 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4740 PyObject *resultobj = 0;
4741 int arg1 ;
4742 wxString *arg2 = 0 ;
4743 bool result;
4744 int val1 ;
4745 int ecode1 = 0 ;
4746 bool temp2 = false ;
4747 PyObject * obj0 = 0 ;
4748 PyObject * obj1 = 0 ;
4749 char * kwnames[] = {
4750 (char *) "id",(char *) "label", NULL
4751 };
4752
4753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4754 ecode1 = SWIG_AsVal_int(obj0, &val1);
4755 if (!SWIG_IsOK(ecode1)) {
4756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4757 }
4758 arg1 = static_cast< int >(val1);
4759 {
4760 arg2 = wxString_in_helper(obj1);
4761 if (arg2 == NULL) SWIG_fail;
4762 temp2 = true;
4763 }
4764 {
4765 PyThreadState* __tstate = wxPyBeginAllowThreads();
4766 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 {
4771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4772 }
4773 {
4774 if (temp2)
4775 delete arg2;
4776 }
4777 return resultobj;
4778 fail:
4779 {
4780 if (temp2)
4781 delete arg2;
4782 }
4783 return NULL;
4784 }
4785
4786
4787 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4788 PyObject *resultobj = 0;
4789 int arg1 ;
4790 bool arg2 = (bool) true ;
4791 wxString arg3 = (wxString) wxPyEmptyString ;
4792 wxString result;
4793 int val1 ;
4794 int ecode1 = 0 ;
4795 bool val2 ;
4796 int ecode2 = 0 ;
4797 PyObject * obj0 = 0 ;
4798 PyObject * obj1 = 0 ;
4799 PyObject * obj2 = 0 ;
4800 char * kwnames[] = {
4801 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4802 };
4803
4804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4805 ecode1 = SWIG_AsVal_int(obj0, &val1);
4806 if (!SWIG_IsOK(ecode1)) {
4807 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4808 }
4809 arg1 = static_cast< int >(val1);
4810 if (obj1) {
4811 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4812 if (!SWIG_IsOK(ecode2)) {
4813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4814 }
4815 arg2 = static_cast< bool >(val2);
4816 }
4817 if (obj2) {
4818 {
4819 wxString* sptr = wxString_in_helper(obj2);
4820 if (sptr == NULL) SWIG_fail;
4821 arg3 = *sptr;
4822 delete sptr;
4823 }
4824 }
4825 {
4826 PyThreadState* __tstate = wxPyBeginAllowThreads();
4827 result = wxGetStockLabel(arg1,arg2,arg3);
4828 wxPyEndAllowThreads(__tstate);
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 {
4832 #if wxUSE_UNICODE
4833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4834 #else
4835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4836 #endif
4837 }
4838 return resultobj;
4839 fail:
4840 return NULL;
4841 }
4842
4843
4844 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4845 PyObject *resultobj = 0;
4846
4847 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4848 {
4849 if (!wxPyCheckForApp()) SWIG_fail;
4850 PyThreadState* __tstate = wxPyBeginAllowThreads();
4851 wxBell();
4852 wxPyEndAllowThreads(__tstate);
4853 if (PyErr_Occurred()) SWIG_fail;
4854 }
4855 resultobj = SWIG_Py_Void();
4856 return resultobj;
4857 fail:
4858 return NULL;
4859 }
4860
4861
4862 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4863 PyObject *resultobj = 0;
4864
4865 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4866 {
4867 if (!wxPyCheckForApp()) SWIG_fail;
4868 PyThreadState* __tstate = wxPyBeginAllowThreads();
4869 wxEndBusyCursor();
4870 wxPyEndAllowThreads(__tstate);
4871 if (PyErr_Occurred()) SWIG_fail;
4872 }
4873 resultobj = SWIG_Py_Void();
4874 return resultobj;
4875 fail:
4876 return NULL;
4877 }
4878
4879
4880 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4881 PyObject *resultobj = 0;
4882 bool arg1 = (bool) true ;
4883 long result;
4884 bool val1 ;
4885 int ecode1 = 0 ;
4886 PyObject * obj0 = 0 ;
4887 char * kwnames[] = {
4888 (char *) "resetTimer", NULL
4889 };
4890
4891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4892 if (obj0) {
4893 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4894 if (!SWIG_IsOK(ecode1)) {
4895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4896 }
4897 arg1 = static_cast< bool >(val1);
4898 }
4899 {
4900 PyThreadState* __tstate = wxPyBeginAllowThreads();
4901 result = (long)wxGetElapsedTime(arg1);
4902 wxPyEndAllowThreads(__tstate);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_From_long(static_cast< long >(result));
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4913 PyObject *resultobj = 0;
4914 bool result;
4915
4916 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4917 {
4918 PyThreadState* __tstate = wxPyBeginAllowThreads();
4919 result = (bool)wxIsBusy();
4920 wxPyEndAllowThreads(__tstate);
4921 if (PyErr_Occurred()) SWIG_fail;
4922 }
4923 {
4924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4925 }
4926 return resultobj;
4927 fail:
4928 return NULL;
4929 }
4930
4931
4932 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4933 PyObject *resultobj = 0;
4934 wxString result;
4935
4936 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4937 {
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 result = wxNow();
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 {
4944 #if wxUSE_UNICODE
4945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4946 #else
4947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4948 #endif
4949 }
4950 return resultobj;
4951 fail:
4952 return NULL;
4953 }
4954
4955
4956 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4957 PyObject *resultobj = 0;
4958 wxString const &arg1_defvalue = wxPyEmptyString ;
4959 wxString *arg1 = (wxString *) &arg1_defvalue ;
4960 bool result;
4961 bool temp1 = false ;
4962 PyObject * obj0 = 0 ;
4963 char * kwnames[] = {
4964 (char *) "command", NULL
4965 };
4966
4967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4968 if (obj0) {
4969 {
4970 arg1 = wxString_in_helper(obj0);
4971 if (arg1 == NULL) SWIG_fail;
4972 temp1 = true;
4973 }
4974 }
4975 {
4976 PyThreadState* __tstate = wxPyBeginAllowThreads();
4977 result = (bool)wxShell((wxString const &)*arg1);
4978 wxPyEndAllowThreads(__tstate);
4979 if (PyErr_Occurred()) SWIG_fail;
4980 }
4981 {
4982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4983 }
4984 {
4985 if (temp1)
4986 delete arg1;
4987 }
4988 return resultobj;
4989 fail:
4990 {
4991 if (temp1)
4992 delete arg1;
4993 }
4994 return NULL;
4995 }
4996
4997
4998 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4999 PyObject *resultobj = 0;
5000
5001 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5002 {
5003 PyThreadState* __tstate = wxPyBeginAllowThreads();
5004 wxStartTimer();
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 resultobj = SWIG_Py_Void();
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5016 PyObject *resultobj = 0;
5017 int *arg1 = (int *) 0 ;
5018 int *arg2 = (int *) 0 ;
5019 int result;
5020 int temp1 ;
5021 int res1 = SWIG_TMPOBJ ;
5022 int temp2 ;
5023 int res2 = SWIG_TMPOBJ ;
5024
5025 arg1 = &temp1;
5026 arg2 = &temp2;
5027 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5028 {
5029 PyThreadState* __tstate = wxPyBeginAllowThreads();
5030 result = (int)wxGetOsVersion(arg1,arg2);
5031 wxPyEndAllowThreads(__tstate);
5032 if (PyErr_Occurred()) SWIG_fail;
5033 }
5034 resultobj = SWIG_From_int(static_cast< int >(result));
5035 if (SWIG_IsTmpObj(res1)) {
5036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5037 } else {
5038 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5040 }
5041 if (SWIG_IsTmpObj(res2)) {
5042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5043 } else {
5044 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5046 }
5047 return resultobj;
5048 fail:
5049 return NULL;
5050 }
5051
5052
5053 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5054 PyObject *resultobj = 0;
5055 wxString result;
5056
5057 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5058 {
5059 PyThreadState* __tstate = wxPyBeginAllowThreads();
5060 result = wxGetOsDescription();
5061 wxPyEndAllowThreads(__tstate);
5062 if (PyErr_Occurred()) SWIG_fail;
5063 }
5064 {
5065 #if wxUSE_UNICODE
5066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5067 #else
5068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5069 #endif
5070 }
5071 return resultobj;
5072 fail:
5073 return NULL;
5074 }
5075
5076
5077 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5078 PyObject *resultobj = 0;
5079 wxMemorySize result;
5080
5081 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 result = wxGetFreeMemory();
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 {
5089 #if wxUSE_LONGLONG
5090 resultobj = PyLong_FromLongLong((&result)->GetValue());
5091 #else
5092 resultobj = PyInt_FromLong(result);
5093 #endif
5094 }
5095 return resultobj;
5096 fail:
5097 return NULL;
5098 }
5099
5100
5101 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5102 PyObject *resultobj = 0;
5103 wxShutdownFlags arg1 ;
5104 bool result;
5105 int val1 ;
5106 int ecode1 = 0 ;
5107 PyObject * obj0 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "wFlags", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5113 ecode1 = SWIG_AsVal_int(obj0, &val1);
5114 if (!SWIG_IsOK(ecode1)) {
5115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5116 }
5117 arg1 = static_cast< wxShutdownFlags >(val1);
5118 {
5119 if (!wxPyCheckForApp()) SWIG_fail;
5120 PyThreadState* __tstate = wxPyBeginAllowThreads();
5121 result = (bool)wxShutdown(arg1);
5122 wxPyEndAllowThreads(__tstate);
5123 if (PyErr_Occurred()) SWIG_fail;
5124 }
5125 {
5126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5127 }
5128 return resultobj;
5129 fail:
5130 return NULL;
5131 }
5132
5133
5134 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5135 PyObject *resultobj = 0;
5136 int arg1 ;
5137 int val1 ;
5138 int ecode1 = 0 ;
5139 PyObject * obj0 = 0 ;
5140 char * kwnames[] = {
5141 (char *) "secs", NULL
5142 };
5143
5144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5145 ecode1 = SWIG_AsVal_int(obj0, &val1);
5146 if (!SWIG_IsOK(ecode1)) {
5147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5148 }
5149 arg1 = static_cast< int >(val1);
5150 {
5151 PyThreadState* __tstate = wxPyBeginAllowThreads();
5152 wxSleep(arg1);
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 resultobj = SWIG_Py_Void();
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5164 PyObject *resultobj = 0;
5165 unsigned long arg1 ;
5166 unsigned long val1 ;
5167 int ecode1 = 0 ;
5168 PyObject * obj0 = 0 ;
5169 char * kwnames[] = {
5170 (char *) "milliseconds", NULL
5171 };
5172
5173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5174 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5175 if (!SWIG_IsOK(ecode1)) {
5176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5177 }
5178 arg1 = static_cast< unsigned long >(val1);
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 wxMilliSleep(arg1);
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 resultobj = SWIG_Py_Void();
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj = 0;
5194 unsigned long arg1 ;
5195 unsigned long val1 ;
5196 int ecode1 = 0 ;
5197 PyObject * obj0 = 0 ;
5198 char * kwnames[] = {
5199 (char *) "microseconds", NULL
5200 };
5201
5202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5203 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5204 if (!SWIG_IsOK(ecode1)) {
5205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5206 }
5207 arg1 = static_cast< unsigned long >(val1);
5208 {
5209 PyThreadState* __tstate = wxPyBeginAllowThreads();
5210 wxMicroSleep(arg1);
5211 wxPyEndAllowThreads(__tstate);
5212 if (PyErr_Occurred()) SWIG_fail;
5213 }
5214 resultobj = SWIG_Py_Void();
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj = 0;
5223 bool arg1 ;
5224 bool val1 ;
5225 int ecode1 = 0 ;
5226 PyObject * obj0 = 0 ;
5227 char * kwnames[] = {
5228 (char *) "enable", NULL
5229 };
5230
5231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5232 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5233 if (!SWIG_IsOK(ecode1)) {
5234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5235 }
5236 arg1 = static_cast< bool >(val1);
5237 {
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 wxEnableTopLevelWindows(arg1);
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_Py_Void();
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj = 0;
5252 wxString *arg1 = 0 ;
5253 wxString result;
5254 bool temp1 = false ;
5255 PyObject * obj0 = 0 ;
5256 char * kwnames[] = {
5257 (char *) "in", NULL
5258 };
5259
5260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5261 {
5262 arg1 = wxString_in_helper(obj0);
5263 if (arg1 == NULL) SWIG_fail;
5264 temp1 = true;
5265 }
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = wxStripMenuCodes((wxString const &)*arg1);
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 {
5273 #if wxUSE_UNICODE
5274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5275 #else
5276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5277 #endif
5278 }
5279 {
5280 if (temp1)
5281 delete arg1;
5282 }
5283 return resultobj;
5284 fail:
5285 {
5286 if (temp1)
5287 delete arg1;
5288 }
5289 return NULL;
5290 }
5291
5292
5293 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5294 PyObject *resultobj = 0;
5295 wxString result;
5296
5297 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5298 {
5299 PyThreadState* __tstate = wxPyBeginAllowThreads();
5300 result = wxGetEmailAddress();
5301 wxPyEndAllowThreads(__tstate);
5302 if (PyErr_Occurred()) SWIG_fail;
5303 }
5304 {
5305 #if wxUSE_UNICODE
5306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5307 #else
5308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5309 #endif
5310 }
5311 return resultobj;
5312 fail:
5313 return NULL;
5314 }
5315
5316
5317 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5318 PyObject *resultobj = 0;
5319 wxString result;
5320
5321 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5322 {
5323 PyThreadState* __tstate = wxPyBeginAllowThreads();
5324 result = wxGetHostName();
5325 wxPyEndAllowThreads(__tstate);
5326 if (PyErr_Occurred()) SWIG_fail;
5327 }
5328 {
5329 #if wxUSE_UNICODE
5330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5331 #else
5332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5333 #endif
5334 }
5335 return resultobj;
5336 fail:
5337 return NULL;
5338 }
5339
5340
5341 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5342 PyObject *resultobj = 0;
5343 wxString result;
5344
5345 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5346 {
5347 PyThreadState* __tstate = wxPyBeginAllowThreads();
5348 result = wxGetFullHostName();
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 {
5353 #if wxUSE_UNICODE
5354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5355 #else
5356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5357 #endif
5358 }
5359 return resultobj;
5360 fail:
5361 return NULL;
5362 }
5363
5364
5365 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5366 PyObject *resultobj = 0;
5367 wxString result;
5368
5369 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5370 {
5371 PyThreadState* __tstate = wxPyBeginAllowThreads();
5372 result = wxGetUserId();
5373 wxPyEndAllowThreads(__tstate);
5374 if (PyErr_Occurred()) SWIG_fail;
5375 }
5376 {
5377 #if wxUSE_UNICODE
5378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5379 #else
5380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5381 #endif
5382 }
5383 return resultobj;
5384 fail:
5385 return NULL;
5386 }
5387
5388
5389 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5390 PyObject *resultobj = 0;
5391 wxString result;
5392
5393 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5394 {
5395 PyThreadState* __tstate = wxPyBeginAllowThreads();
5396 result = wxGetUserName();
5397 wxPyEndAllowThreads(__tstate);
5398 if (PyErr_Occurred()) SWIG_fail;
5399 }
5400 {
5401 #if wxUSE_UNICODE
5402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5403 #else
5404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5405 #endif
5406 }
5407 return resultobj;
5408 fail:
5409 return NULL;
5410 }
5411
5412
5413 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5414 PyObject *resultobj = 0;
5415 wxString result;
5416
5417 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5418 {
5419 PyThreadState* __tstate = wxPyBeginAllowThreads();
5420 result = wxGetHomeDir();
5421 wxPyEndAllowThreads(__tstate);
5422 if (PyErr_Occurred()) SWIG_fail;
5423 }
5424 {
5425 #if wxUSE_UNICODE
5426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5427 #else
5428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5429 #endif
5430 }
5431 return resultobj;
5432 fail:
5433 return NULL;
5434 }
5435
5436
5437 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5438 PyObject *resultobj = 0;
5439 wxString const &arg1_defvalue = wxPyEmptyString ;
5440 wxString *arg1 = (wxString *) &arg1_defvalue ;
5441 wxString result;
5442 bool temp1 = false ;
5443 PyObject * obj0 = 0 ;
5444 char * kwnames[] = {
5445 (char *) "user", NULL
5446 };
5447
5448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5449 if (obj0) {
5450 {
5451 arg1 = wxString_in_helper(obj0);
5452 if (arg1 == NULL) SWIG_fail;
5453 temp1 = true;
5454 }
5455 }
5456 {
5457 PyThreadState* __tstate = wxPyBeginAllowThreads();
5458 result = wxGetUserHome((wxString const &)*arg1);
5459 wxPyEndAllowThreads(__tstate);
5460 if (PyErr_Occurred()) SWIG_fail;
5461 }
5462 {
5463 #if wxUSE_UNICODE
5464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5465 #else
5466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5467 #endif
5468 }
5469 {
5470 if (temp1)
5471 delete arg1;
5472 }
5473 return resultobj;
5474 fail:
5475 {
5476 if (temp1)
5477 delete arg1;
5478 }
5479 return NULL;
5480 }
5481
5482
5483 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5484 PyObject *resultobj = 0;
5485 unsigned long result;
5486
5487 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5488 {
5489 PyThreadState* __tstate = wxPyBeginAllowThreads();
5490 result = (unsigned long)wxGetProcessId();
5491 wxPyEndAllowThreads(__tstate);
5492 if (PyErr_Occurred()) SWIG_fail;
5493 }
5494 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5495 return resultobj;
5496 fail:
5497 return NULL;
5498 }
5499
5500
5501 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5502 PyObject *resultobj = 0;
5503
5504 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 wxTrap();
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 resultobj = SWIG_Py_Void();
5512 return resultobj;
5513 fail:
5514 return NULL;
5515 }
5516
5517
5518 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5519 PyObject *resultobj = 0;
5520 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5521 wxString *arg1 = (wxString *) &arg1_defvalue ;
5522 wxString const &arg2_defvalue = wxPyEmptyString ;
5523 wxString *arg2 = (wxString *) &arg2_defvalue ;
5524 wxString const &arg3_defvalue = wxPyEmptyString ;
5525 wxString *arg3 = (wxString *) &arg3_defvalue ;
5526 wxString const &arg4_defvalue = wxPyEmptyString ;
5527 wxString *arg4 = (wxString *) &arg4_defvalue ;
5528 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5529 wxString *arg5 = (wxString *) &arg5_defvalue ;
5530 int arg6 = (int) 0 ;
5531 wxWindow *arg7 = (wxWindow *) NULL ;
5532 int arg8 = (int) -1 ;
5533 int arg9 = (int) -1 ;
5534 wxString result;
5535 bool temp1 = false ;
5536 bool temp2 = false ;
5537 bool temp3 = false ;
5538 bool temp4 = false ;
5539 bool temp5 = false ;
5540 int val6 ;
5541 int ecode6 = 0 ;
5542 void *argp7 = 0 ;
5543 int res7 = 0 ;
5544 int val8 ;
5545 int ecode8 = 0 ;
5546 int val9 ;
5547 int ecode9 = 0 ;
5548 PyObject * obj0 = 0 ;
5549 PyObject * obj1 = 0 ;
5550 PyObject * obj2 = 0 ;
5551 PyObject * obj3 = 0 ;
5552 PyObject * obj4 = 0 ;
5553 PyObject * obj5 = 0 ;
5554 PyObject * obj6 = 0 ;
5555 PyObject * obj7 = 0 ;
5556 PyObject * obj8 = 0 ;
5557 char * kwnames[] = {
5558 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5559 };
5560
5561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5562 if (obj0) {
5563 {
5564 arg1 = wxString_in_helper(obj0);
5565 if (arg1 == NULL) SWIG_fail;
5566 temp1 = true;
5567 }
5568 }
5569 if (obj1) {
5570 {
5571 arg2 = wxString_in_helper(obj1);
5572 if (arg2 == NULL) SWIG_fail;
5573 temp2 = true;
5574 }
5575 }
5576 if (obj2) {
5577 {
5578 arg3 = wxString_in_helper(obj2);
5579 if (arg3 == NULL) SWIG_fail;
5580 temp3 = true;
5581 }
5582 }
5583 if (obj3) {
5584 {
5585 arg4 = wxString_in_helper(obj3);
5586 if (arg4 == NULL) SWIG_fail;
5587 temp4 = true;
5588 }
5589 }
5590 if (obj4) {
5591 {
5592 arg5 = wxString_in_helper(obj4);
5593 if (arg5 == NULL) SWIG_fail;
5594 temp5 = true;
5595 }
5596 }
5597 if (obj5) {
5598 ecode6 = SWIG_AsVal_int(obj5, &val6);
5599 if (!SWIG_IsOK(ecode6)) {
5600 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5601 }
5602 arg6 = static_cast< int >(val6);
5603 }
5604 if (obj6) {
5605 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5606 if (!SWIG_IsOK(res7)) {
5607 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5608 }
5609 arg7 = reinterpret_cast< wxWindow * >(argp7);
5610 }
5611 if (obj7) {
5612 ecode8 = SWIG_AsVal_int(obj7, &val8);
5613 if (!SWIG_IsOK(ecode8)) {
5614 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5615 }
5616 arg8 = static_cast< int >(val8);
5617 }
5618 if (obj8) {
5619 ecode9 = SWIG_AsVal_int(obj8, &val9);
5620 if (!SWIG_IsOK(ecode9)) {
5621 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5622 }
5623 arg9 = static_cast< int >(val9);
5624 }
5625 {
5626 if (!wxPyCheckForApp()) SWIG_fail;
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5629 wxPyEndAllowThreads(__tstate);
5630 if (PyErr_Occurred()) SWIG_fail;
5631 }
5632 {
5633 #if wxUSE_UNICODE
5634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5635 #else
5636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5637 #endif
5638 }
5639 {
5640 if (temp1)
5641 delete arg1;
5642 }
5643 {
5644 if (temp2)
5645 delete arg2;
5646 }
5647 {
5648 if (temp3)
5649 delete arg3;
5650 }
5651 {
5652 if (temp4)
5653 delete arg4;
5654 }
5655 {
5656 if (temp5)
5657 delete arg5;
5658 }
5659 return resultobj;
5660 fail:
5661 {
5662 if (temp1)
5663 delete arg1;
5664 }
5665 {
5666 if (temp2)
5667 delete arg2;
5668 }
5669 {
5670 if (temp3)
5671 delete arg3;
5672 }
5673 {
5674 if (temp4)
5675 delete arg4;
5676 }
5677 {
5678 if (temp5)
5679 delete arg5;
5680 }
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj = 0;
5687 wxString *arg1 = 0 ;
5688 wxString *arg2 = 0 ;
5689 wxString const &arg3_defvalue = wxPyEmptyString ;
5690 wxString *arg3 = (wxString *) &arg3_defvalue ;
5691 wxWindow *arg4 = (wxWindow *) NULL ;
5692 wxString result;
5693 bool temp1 = false ;
5694 bool temp2 = false ;
5695 bool temp3 = false ;
5696 void *argp4 = 0 ;
5697 int res4 = 0 ;
5698 PyObject * obj0 = 0 ;
5699 PyObject * obj1 = 0 ;
5700 PyObject * obj2 = 0 ;
5701 PyObject * obj3 = 0 ;
5702 char * kwnames[] = {
5703 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5704 };
5705
5706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5707 {
5708 arg1 = wxString_in_helper(obj0);
5709 if (arg1 == NULL) SWIG_fail;
5710 temp1 = true;
5711 }
5712 {
5713 arg2 = wxString_in_helper(obj1);
5714 if (arg2 == NULL) SWIG_fail;
5715 temp2 = true;
5716 }
5717 if (obj2) {
5718 {
5719 arg3 = wxString_in_helper(obj2);
5720 if (arg3 == NULL) SWIG_fail;
5721 temp3 = true;
5722 }
5723 }
5724 if (obj3) {
5725 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5726 if (!SWIG_IsOK(res4)) {
5727 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5728 }
5729 arg4 = reinterpret_cast< wxWindow * >(argp4);
5730 }
5731 {
5732 if (!wxPyCheckForApp()) SWIG_fail;
5733 PyThreadState* __tstate = wxPyBeginAllowThreads();
5734 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5735 wxPyEndAllowThreads(__tstate);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 {
5739 #if wxUSE_UNICODE
5740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5741 #else
5742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5743 #endif
5744 }
5745 {
5746 if (temp1)
5747 delete arg1;
5748 }
5749 {
5750 if (temp2)
5751 delete arg2;
5752 }
5753 {
5754 if (temp3)
5755 delete arg3;
5756 }
5757 return resultobj;
5758 fail:
5759 {
5760 if (temp1)
5761 delete arg1;
5762 }
5763 {
5764 if (temp2)
5765 delete arg2;
5766 }
5767 {
5768 if (temp3)
5769 delete arg3;
5770 }
5771 return NULL;
5772 }
5773
5774
5775 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5776 PyObject *resultobj = 0;
5777 wxString *arg1 = 0 ;
5778 wxString *arg2 = 0 ;
5779 wxString const &arg3_defvalue = wxPyEmptyString ;
5780 wxString *arg3 = (wxString *) &arg3_defvalue ;
5781 wxWindow *arg4 = (wxWindow *) NULL ;
5782 wxString result;
5783 bool temp1 = false ;
5784 bool temp2 = false ;
5785 bool temp3 = false ;
5786 void *argp4 = 0 ;
5787 int res4 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 PyObject * obj1 = 0 ;
5790 PyObject * obj2 = 0 ;
5791 PyObject * obj3 = 0 ;
5792 char * kwnames[] = {
5793 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5794 };
5795
5796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5797 {
5798 arg1 = wxString_in_helper(obj0);
5799 if (arg1 == NULL) SWIG_fail;
5800 temp1 = true;
5801 }
5802 {
5803 arg2 = wxString_in_helper(obj1);
5804 if (arg2 == NULL) SWIG_fail;
5805 temp2 = true;
5806 }
5807 if (obj2) {
5808 {
5809 arg3 = wxString_in_helper(obj2);
5810 if (arg3 == NULL) SWIG_fail;
5811 temp3 = true;
5812 }
5813 }
5814 if (obj3) {
5815 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5816 if (!SWIG_IsOK(res4)) {
5817 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5818 }
5819 arg4 = reinterpret_cast< wxWindow * >(argp4);
5820 }
5821 {
5822 if (!wxPyCheckForApp()) SWIG_fail;
5823 PyThreadState* __tstate = wxPyBeginAllowThreads();
5824 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5825 wxPyEndAllowThreads(__tstate);
5826 if (PyErr_Occurred()) SWIG_fail;
5827 }
5828 {
5829 #if wxUSE_UNICODE
5830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5831 #else
5832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5833 #endif
5834 }
5835 {
5836 if (temp1)
5837 delete arg1;
5838 }
5839 {
5840 if (temp2)
5841 delete arg2;
5842 }
5843 {
5844 if (temp3)
5845 delete arg3;
5846 }
5847 return resultobj;
5848 fail:
5849 {
5850 if (temp1)
5851 delete arg1;
5852 }
5853 {
5854 if (temp2)
5855 delete arg2;
5856 }
5857 {
5858 if (temp3)
5859 delete arg3;
5860 }
5861 return NULL;
5862 }
5863
5864
5865 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj = 0;
5867 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5868 wxString *arg1 = (wxString *) &arg1_defvalue ;
5869 wxString const &arg2_defvalue = wxPyEmptyString ;
5870 wxString *arg2 = (wxString *) &arg2_defvalue ;
5871 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5872 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5873 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5874 wxWindow *arg5 = (wxWindow *) NULL ;
5875 wxString result;
5876 bool temp1 = false ;
5877 bool temp2 = false ;
5878 long val3 ;
5879 int ecode3 = 0 ;
5880 wxPoint temp4 ;
5881 void *argp5 = 0 ;
5882 int res5 = 0 ;
5883 PyObject * obj0 = 0 ;
5884 PyObject * obj1 = 0 ;
5885 PyObject * obj2 = 0 ;
5886 PyObject * obj3 = 0 ;
5887 PyObject * obj4 = 0 ;
5888 char * kwnames[] = {
5889 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5890 };
5891
5892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5893 if (obj0) {
5894 {
5895 arg1 = wxString_in_helper(obj0);
5896 if (arg1 == NULL) SWIG_fail;
5897 temp1 = true;
5898 }
5899 }
5900 if (obj1) {
5901 {
5902 arg2 = wxString_in_helper(obj1);
5903 if (arg2 == NULL) SWIG_fail;
5904 temp2 = true;
5905 }
5906 }
5907 if (obj2) {
5908 ecode3 = SWIG_AsVal_long(obj2, &val3);
5909 if (!SWIG_IsOK(ecode3)) {
5910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5911 }
5912 arg3 = static_cast< long >(val3);
5913 }
5914 if (obj3) {
5915 {
5916 arg4 = &temp4;
5917 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5918 }
5919 }
5920 if (obj4) {
5921 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5922 if (!SWIG_IsOK(res5)) {
5923 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5924 }
5925 arg5 = reinterpret_cast< wxWindow * >(argp5);
5926 }
5927 {
5928 if (!wxPyCheckForApp()) SWIG_fail;
5929 PyThreadState* __tstate = wxPyBeginAllowThreads();
5930 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 {
5935 #if wxUSE_UNICODE
5936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5937 #else
5938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5939 #endif
5940 }
5941 {
5942 if (temp1)
5943 delete arg1;
5944 }
5945 {
5946 if (temp2)
5947 delete arg2;
5948 }
5949 return resultobj;
5950 fail:
5951 {
5952 if (temp1)
5953 delete arg1;
5954 }
5955 {
5956 if (temp2)
5957 delete arg2;
5958 }
5959 return NULL;
5960 }
5961
5962
5963 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj = 0;
5965 wxString *arg1 = 0 ;
5966 wxString const &arg2_defvalue = wxPyEmptyString ;
5967 wxString *arg2 = (wxString *) &arg2_defvalue ;
5968 wxString const &arg3_defvalue = wxPyEmptyString ;
5969 wxString *arg3 = (wxString *) &arg3_defvalue ;
5970 wxWindow *arg4 = (wxWindow *) NULL ;
5971 int arg5 = (int) -1 ;
5972 int arg6 = (int) -1 ;
5973 bool arg7 = (bool) true ;
5974 wxString result;
5975 bool temp1 = false ;
5976 bool temp2 = false ;
5977 bool temp3 = false ;
5978 void *argp4 = 0 ;
5979 int res4 = 0 ;
5980 int val5 ;
5981 int ecode5 = 0 ;
5982 int val6 ;
5983 int ecode6 = 0 ;
5984 bool val7 ;
5985 int ecode7 = 0 ;
5986 PyObject * obj0 = 0 ;
5987 PyObject * obj1 = 0 ;
5988 PyObject * obj2 = 0 ;
5989 PyObject * obj3 = 0 ;
5990 PyObject * obj4 = 0 ;
5991 PyObject * obj5 = 0 ;
5992 PyObject * obj6 = 0 ;
5993 char * kwnames[] = {
5994 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5995 };
5996
5997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5998 {
5999 arg1 = wxString_in_helper(obj0);
6000 if (arg1 == NULL) SWIG_fail;
6001 temp1 = true;
6002 }
6003 if (obj1) {
6004 {
6005 arg2 = wxString_in_helper(obj1);
6006 if (arg2 == NULL) SWIG_fail;
6007 temp2 = true;
6008 }
6009 }
6010 if (obj2) {
6011 {
6012 arg3 = wxString_in_helper(obj2);
6013 if (arg3 == NULL) SWIG_fail;
6014 temp3 = true;
6015 }
6016 }
6017 if (obj3) {
6018 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6019 if (!SWIG_IsOK(res4)) {
6020 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6021 }
6022 arg4 = reinterpret_cast< wxWindow * >(argp4);
6023 }
6024 if (obj4) {
6025 ecode5 = SWIG_AsVal_int(obj4, &val5);
6026 if (!SWIG_IsOK(ecode5)) {
6027 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6028 }
6029 arg5 = static_cast< int >(val5);
6030 }
6031 if (obj5) {
6032 ecode6 = SWIG_AsVal_int(obj5, &val6);
6033 if (!SWIG_IsOK(ecode6)) {
6034 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6035 }
6036 arg6 = static_cast< int >(val6);
6037 }
6038 if (obj6) {
6039 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6040 if (!SWIG_IsOK(ecode7)) {
6041 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6042 }
6043 arg7 = static_cast< bool >(val7);
6044 }
6045 {
6046 if (!wxPyCheckForApp()) SWIG_fail;
6047 PyThreadState* __tstate = wxPyBeginAllowThreads();
6048 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6049 wxPyEndAllowThreads(__tstate);
6050 if (PyErr_Occurred()) SWIG_fail;
6051 }
6052 {
6053 #if wxUSE_UNICODE
6054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6055 #else
6056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6057 #endif
6058 }
6059 {
6060 if (temp1)
6061 delete arg1;
6062 }
6063 {
6064 if (temp2)
6065 delete arg2;
6066 }
6067 {
6068 if (temp3)
6069 delete arg3;
6070 }
6071 return resultobj;
6072 fail:
6073 {
6074 if (temp1)
6075 delete arg1;
6076 }
6077 {
6078 if (temp2)
6079 delete arg2;
6080 }
6081 {
6082 if (temp3)
6083 delete arg3;
6084 }
6085 return NULL;
6086 }
6087
6088
6089 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6090 PyObject *resultobj = 0;
6091 wxString *arg1 = 0 ;
6092 wxString const &arg2_defvalue = wxPyEmptyString ;
6093 wxString *arg2 = (wxString *) &arg2_defvalue ;
6094 wxString const &arg3_defvalue = wxPyEmptyString ;
6095 wxString *arg3 = (wxString *) &arg3_defvalue ;
6096 wxWindow *arg4 = (wxWindow *) NULL ;
6097 wxString result;
6098 bool temp1 = false ;
6099 bool temp2 = false ;
6100 bool temp3 = false ;
6101 void *argp4 = 0 ;
6102 int res4 = 0 ;
6103 PyObject * obj0 = 0 ;
6104 PyObject * obj1 = 0 ;
6105 PyObject * obj2 = 0 ;
6106 PyObject * obj3 = 0 ;
6107 char * kwnames[] = {
6108 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6109 };
6110
6111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6112 {
6113 arg1 = wxString_in_helper(obj0);
6114 if (arg1 == NULL) SWIG_fail;
6115 temp1 = true;
6116 }
6117 if (obj1) {
6118 {
6119 arg2 = wxString_in_helper(obj1);
6120 if (arg2 == NULL) SWIG_fail;
6121 temp2 = true;
6122 }
6123 }
6124 if (obj2) {
6125 {
6126 arg3 = wxString_in_helper(obj2);
6127 if (arg3 == NULL) SWIG_fail;
6128 temp3 = true;
6129 }
6130 }
6131 if (obj3) {
6132 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6133 if (!SWIG_IsOK(res4)) {
6134 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6135 }
6136 arg4 = reinterpret_cast< wxWindow * >(argp4);
6137 }
6138 {
6139 if (!wxPyCheckForApp()) SWIG_fail;
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 {
6146 #if wxUSE_UNICODE
6147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6148 #else
6149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6150 #endif
6151 }
6152 {
6153 if (temp1)
6154 delete arg1;
6155 }
6156 {
6157 if (temp2)
6158 delete arg2;
6159 }
6160 {
6161 if (temp3)
6162 delete arg3;
6163 }
6164 return resultobj;
6165 fail:
6166 {
6167 if (temp1)
6168 delete arg1;
6169 }
6170 {
6171 if (temp2)
6172 delete arg2;
6173 }
6174 {
6175 if (temp3)
6176 delete arg3;
6177 }
6178 return NULL;
6179 }
6180
6181
6182 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj = 0;
6184 wxString *arg1 = 0 ;
6185 wxString *arg2 = 0 ;
6186 int arg3 ;
6187 wxString *arg4 = (wxString *) 0 ;
6188 wxWindow *arg5 = (wxWindow *) NULL ;
6189 int arg6 = (int) -1 ;
6190 int arg7 = (int) -1 ;
6191 bool arg8 = (bool) true ;
6192 int arg9 = (int) 150 ;
6193 int arg10 = (int) 200 ;
6194 wxString result;
6195 bool temp1 = false ;
6196 bool temp2 = false ;
6197 void *argp5 = 0 ;
6198 int res5 = 0 ;
6199 int val6 ;
6200 int ecode6 = 0 ;
6201 int val7 ;
6202 int ecode7 = 0 ;
6203 bool val8 ;
6204 int ecode8 = 0 ;
6205 int val9 ;
6206 int ecode9 = 0 ;
6207 int val10 ;
6208 int ecode10 = 0 ;
6209 PyObject * obj0 = 0 ;
6210 PyObject * obj1 = 0 ;
6211 PyObject * obj2 = 0 ;
6212 PyObject * obj3 = 0 ;
6213 PyObject * obj4 = 0 ;
6214 PyObject * obj5 = 0 ;
6215 PyObject * obj6 = 0 ;
6216 PyObject * obj7 = 0 ;
6217 PyObject * obj8 = 0 ;
6218 char * kwnames[] = {
6219 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6220 };
6221
6222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6223 {
6224 arg1 = wxString_in_helper(obj0);
6225 if (arg1 == NULL) SWIG_fail;
6226 temp1 = true;
6227 }
6228 {
6229 arg2 = wxString_in_helper(obj1);
6230 if (arg2 == NULL) SWIG_fail;
6231 temp2 = true;
6232 }
6233 {
6234 arg3 = PyList_Size(obj2);
6235 arg4 = wxString_LIST_helper(obj2);
6236 if (arg4 == NULL) SWIG_fail;
6237 }
6238 if (obj3) {
6239 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6240 if (!SWIG_IsOK(res5)) {
6241 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6242 }
6243 arg5 = reinterpret_cast< wxWindow * >(argp5);
6244 }
6245 if (obj4) {
6246 ecode6 = SWIG_AsVal_int(obj4, &val6);
6247 if (!SWIG_IsOK(ecode6)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6249 }
6250 arg6 = static_cast< int >(val6);
6251 }
6252 if (obj5) {
6253 ecode7 = SWIG_AsVal_int(obj5, &val7);
6254 if (!SWIG_IsOK(ecode7)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6256 }
6257 arg7 = static_cast< int >(val7);
6258 }
6259 if (obj6) {
6260 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6261 if (!SWIG_IsOK(ecode8)) {
6262 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6263 }
6264 arg8 = static_cast< bool >(val8);
6265 }
6266 if (obj7) {
6267 ecode9 = SWIG_AsVal_int(obj7, &val9);
6268 if (!SWIG_IsOK(ecode9)) {
6269 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6270 }
6271 arg9 = static_cast< int >(val9);
6272 }
6273 if (obj8) {
6274 ecode10 = SWIG_AsVal_int(obj8, &val10);
6275 if (!SWIG_IsOK(ecode10)) {
6276 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6277 }
6278 arg10 = static_cast< int >(val10);
6279 }
6280 {
6281 if (!wxPyCheckForApp()) SWIG_fail;
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 {
6288 #if wxUSE_UNICODE
6289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6290 #else
6291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6292 #endif
6293 }
6294 {
6295 if (temp1)
6296 delete arg1;
6297 }
6298 {
6299 if (temp2)
6300 delete arg2;
6301 }
6302 {
6303 if (arg4) delete [] arg4;
6304 }
6305 return resultobj;
6306 fail:
6307 {
6308 if (temp1)
6309 delete arg1;
6310 }
6311 {
6312 if (temp2)
6313 delete arg2;
6314 }
6315 {
6316 if (arg4) delete [] arg4;
6317 }
6318 return NULL;
6319 }
6320
6321
6322 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6323 PyObject *resultobj = 0;
6324 wxString *arg1 = 0 ;
6325 wxString *arg2 = 0 ;
6326 int arg3 ;
6327 wxString *arg4 = (wxString *) 0 ;
6328 wxWindow *arg5 = (wxWindow *) NULL ;
6329 int arg6 = (int) -1 ;
6330 int arg7 = (int) -1 ;
6331 bool arg8 = (bool) true ;
6332 int arg9 = (int) 150 ;
6333 int arg10 = (int) 200 ;
6334 int result;
6335 bool temp1 = false ;
6336 bool temp2 = false ;
6337 void *argp5 = 0 ;
6338 int res5 = 0 ;
6339 int val6 ;
6340 int ecode6 = 0 ;
6341 int val7 ;
6342 int ecode7 = 0 ;
6343 bool val8 ;
6344 int ecode8 = 0 ;
6345 int val9 ;
6346 int ecode9 = 0 ;
6347 int val10 ;
6348 int ecode10 = 0 ;
6349 PyObject * obj0 = 0 ;
6350 PyObject * obj1 = 0 ;
6351 PyObject * obj2 = 0 ;
6352 PyObject * obj3 = 0 ;
6353 PyObject * obj4 = 0 ;
6354 PyObject * obj5 = 0 ;
6355 PyObject * obj6 = 0 ;
6356 PyObject * obj7 = 0 ;
6357 PyObject * obj8 = 0 ;
6358 char * kwnames[] = {
6359 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6360 };
6361
6362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6363 {
6364 arg1 = wxString_in_helper(obj0);
6365 if (arg1 == NULL) SWIG_fail;
6366 temp1 = true;
6367 }
6368 {
6369 arg2 = wxString_in_helper(obj1);
6370 if (arg2 == NULL) SWIG_fail;
6371 temp2 = true;
6372 }
6373 {
6374 arg3 = PyList_Size(obj2);
6375 arg4 = wxString_LIST_helper(obj2);
6376 if (arg4 == NULL) SWIG_fail;
6377 }
6378 if (obj3) {
6379 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6380 if (!SWIG_IsOK(res5)) {
6381 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6382 }
6383 arg5 = reinterpret_cast< wxWindow * >(argp5);
6384 }
6385 if (obj4) {
6386 ecode6 = SWIG_AsVal_int(obj4, &val6);
6387 if (!SWIG_IsOK(ecode6)) {
6388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6389 }
6390 arg6 = static_cast< int >(val6);
6391 }
6392 if (obj5) {
6393 ecode7 = SWIG_AsVal_int(obj5, &val7);
6394 if (!SWIG_IsOK(ecode7)) {
6395 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6396 }
6397 arg7 = static_cast< int >(val7);
6398 }
6399 if (obj6) {
6400 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6401 if (!SWIG_IsOK(ecode8)) {
6402 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6403 }
6404 arg8 = static_cast< bool >(val8);
6405 }
6406 if (obj7) {
6407 ecode9 = SWIG_AsVal_int(obj7, &val9);
6408 if (!SWIG_IsOK(ecode9)) {
6409 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6410 }
6411 arg9 = static_cast< int >(val9);
6412 }
6413 if (obj8) {
6414 ecode10 = SWIG_AsVal_int(obj8, &val10);
6415 if (!SWIG_IsOK(ecode10)) {
6416 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6417 }
6418 arg10 = static_cast< int >(val10);
6419 }
6420 {
6421 if (!wxPyCheckForApp()) SWIG_fail;
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6424 wxPyEndAllowThreads(__tstate);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 resultobj = SWIG_From_int(static_cast< int >(result));
6428 {
6429 if (temp1)
6430 delete arg1;
6431 }
6432 {
6433 if (temp2)
6434 delete arg2;
6435 }
6436 {
6437 if (arg4) delete [] arg4;
6438 }
6439 return resultobj;
6440 fail:
6441 {
6442 if (temp1)
6443 delete arg1;
6444 }
6445 {
6446 if (temp2)
6447 delete arg2;
6448 }
6449 {
6450 if (arg4) delete [] arg4;
6451 }
6452 return NULL;
6453 }
6454
6455
6456 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj = 0;
6458 wxString *arg1 = 0 ;
6459 wxString const &arg2_defvalue = wxPyEmptyString ;
6460 wxString *arg2 = (wxString *) &arg2_defvalue ;
6461 int arg3 = (int) wxOK|wxCENTRE ;
6462 wxWindow *arg4 = (wxWindow *) NULL ;
6463 int arg5 = (int) -1 ;
6464 int arg6 = (int) -1 ;
6465 int result;
6466 bool temp1 = false ;
6467 bool temp2 = false ;
6468 int val3 ;
6469 int ecode3 = 0 ;
6470 void *argp4 = 0 ;
6471 int res4 = 0 ;
6472 int val5 ;
6473 int ecode5 = 0 ;
6474 int val6 ;
6475 int ecode6 = 0 ;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 PyObject * obj2 = 0 ;
6479 PyObject * obj3 = 0 ;
6480 PyObject * obj4 = 0 ;
6481 PyObject * obj5 = 0 ;
6482 char * kwnames[] = {
6483 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6484 };
6485
6486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6487 {
6488 arg1 = wxString_in_helper(obj0);
6489 if (arg1 == NULL) SWIG_fail;
6490 temp1 = true;
6491 }
6492 if (obj1) {
6493 {
6494 arg2 = wxString_in_helper(obj1);
6495 if (arg2 == NULL) SWIG_fail;
6496 temp2 = true;
6497 }
6498 }
6499 if (obj2) {
6500 ecode3 = SWIG_AsVal_int(obj2, &val3);
6501 if (!SWIG_IsOK(ecode3)) {
6502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6503 }
6504 arg3 = static_cast< int >(val3);
6505 }
6506 if (obj3) {
6507 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6508 if (!SWIG_IsOK(res4)) {
6509 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6510 }
6511 arg4 = reinterpret_cast< wxWindow * >(argp4);
6512 }
6513 if (obj4) {
6514 ecode5 = SWIG_AsVal_int(obj4, &val5);
6515 if (!SWIG_IsOK(ecode5)) {
6516 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6517 }
6518 arg5 = static_cast< int >(val5);
6519 }
6520 if (obj5) {
6521 ecode6 = SWIG_AsVal_int(obj5, &val6);
6522 if (!SWIG_IsOK(ecode6)) {
6523 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6524 }
6525 arg6 = static_cast< int >(val6);
6526 }
6527 {
6528 if (!wxPyCheckForApp()) SWIG_fail;
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_From_int(static_cast< int >(result));
6535 {
6536 if (temp1)
6537 delete arg1;
6538 }
6539 {
6540 if (temp2)
6541 delete arg2;
6542 }
6543 return resultobj;
6544 fail:
6545 {
6546 if (temp1)
6547 delete arg1;
6548 }
6549 {
6550 if (temp2)
6551 delete arg2;
6552 }
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxString *arg1 = 0 ;
6560 wxString *arg2 = 0 ;
6561 wxString *arg3 = 0 ;
6562 long arg4 ;
6563 long arg5 = (long) 0 ;
6564 long arg6 = (long) 100 ;
6565 wxWindow *arg7 = (wxWindow *) NULL ;
6566 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6567 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6568 long result;
6569 bool temp1 = false ;
6570 bool temp2 = false ;
6571 bool temp3 = false ;
6572 long val4 ;
6573 int ecode4 = 0 ;
6574 long val5 ;
6575 int ecode5 = 0 ;
6576 long val6 ;
6577 int ecode6 = 0 ;
6578 void *argp7 = 0 ;
6579 int res7 = 0 ;
6580 wxPoint temp8 ;
6581 PyObject * obj0 = 0 ;
6582 PyObject * obj1 = 0 ;
6583 PyObject * obj2 = 0 ;
6584 PyObject * obj3 = 0 ;
6585 PyObject * obj4 = 0 ;
6586 PyObject * obj5 = 0 ;
6587 PyObject * obj6 = 0 ;
6588 PyObject * obj7 = 0 ;
6589 char * kwnames[] = {
6590 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6591 };
6592
6593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6594 {
6595 arg1 = wxString_in_helper(obj0);
6596 if (arg1 == NULL) SWIG_fail;
6597 temp1 = true;
6598 }
6599 {
6600 arg2 = wxString_in_helper(obj1);
6601 if (arg2 == NULL) SWIG_fail;
6602 temp2 = true;
6603 }
6604 {
6605 arg3 = wxString_in_helper(obj2);
6606 if (arg3 == NULL) SWIG_fail;
6607 temp3 = true;
6608 }
6609 ecode4 = SWIG_AsVal_long(obj3, &val4);
6610 if (!SWIG_IsOK(ecode4)) {
6611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6612 }
6613 arg4 = static_cast< long >(val4);
6614 if (obj4) {
6615 ecode5 = SWIG_AsVal_long(obj4, &val5);
6616 if (!SWIG_IsOK(ecode5)) {
6617 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6618 }
6619 arg5 = static_cast< long >(val5);
6620 }
6621 if (obj5) {
6622 ecode6 = SWIG_AsVal_long(obj5, &val6);
6623 if (!SWIG_IsOK(ecode6)) {
6624 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6625 }
6626 arg6 = static_cast< long >(val6);
6627 }
6628 if (obj6) {
6629 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6630 if (!SWIG_IsOK(res7)) {
6631 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6632 }
6633 arg7 = reinterpret_cast< wxWindow * >(argp7);
6634 }
6635 if (obj7) {
6636 {
6637 arg8 = &temp8;
6638 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6639 }
6640 }
6641 {
6642 if (!wxPyCheckForApp()) SWIG_fail;
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6645 wxPyEndAllowThreads(__tstate);
6646 if (PyErr_Occurred()) SWIG_fail;
6647 }
6648 resultobj = SWIG_From_long(static_cast< long >(result));
6649 {
6650 if (temp1)
6651 delete arg1;
6652 }
6653 {
6654 if (temp2)
6655 delete arg2;
6656 }
6657 {
6658 if (temp3)
6659 delete arg3;
6660 }
6661 return resultobj;
6662 fail:
6663 {
6664 if (temp1)
6665 delete arg1;
6666 }
6667 {
6668 if (temp2)
6669 delete arg2;
6670 }
6671 {
6672 if (temp3)
6673 delete arg3;
6674 }
6675 return NULL;
6676 }
6677
6678
6679 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6680 PyObject *resultobj = 0;
6681 bool result;
6682
6683 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6684 {
6685 if (!wxPyCheckForApp()) SWIG_fail;
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (bool)wxColourDisplay();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 {
6692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6693 }
6694 return resultobj;
6695 fail:
6696 return NULL;
6697 }
6698
6699
6700 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6701 PyObject *resultobj = 0;
6702 int result;
6703
6704 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6705 {
6706 if (!wxPyCheckForApp()) SWIG_fail;
6707 PyThreadState* __tstate = wxPyBeginAllowThreads();
6708 result = (int)wxDisplayDepth();
6709 wxPyEndAllowThreads(__tstate);
6710 if (PyErr_Occurred()) SWIG_fail;
6711 }
6712 resultobj = SWIG_From_int(static_cast< int >(result));
6713 return resultobj;
6714 fail:
6715 return NULL;
6716 }
6717
6718
6719 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6720 PyObject *resultobj = 0;
6721 int result;
6722
6723 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6724 {
6725 if (!wxPyCheckForApp()) SWIG_fail;
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (int)wxGetDisplayDepth();
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 resultobj = SWIG_From_int(static_cast< int >(result));
6732 return resultobj;
6733 fail:
6734 return NULL;
6735 }
6736
6737
6738 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6739 PyObject *resultobj = 0;
6740 int *arg1 = (int *) 0 ;
6741 int *arg2 = (int *) 0 ;
6742 int temp1 ;
6743 int res1 = SWIG_TMPOBJ ;
6744 int temp2 ;
6745 int res2 = SWIG_TMPOBJ ;
6746
6747 arg1 = &temp1;
6748 arg2 = &temp2;
6749 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6750 {
6751 if (!wxPyCheckForApp()) SWIG_fail;
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 wxDisplaySize(arg1,arg2);
6754 wxPyEndAllowThreads(__tstate);
6755 if (PyErr_Occurred()) SWIG_fail;
6756 }
6757 resultobj = SWIG_Py_Void();
6758 if (SWIG_IsTmpObj(res1)) {
6759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6760 } else {
6761 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6763 }
6764 if (SWIG_IsTmpObj(res2)) {
6765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6766 } else {
6767 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6769 }
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6777 PyObject *resultobj = 0;
6778 wxSize result;
6779
6780 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6781 {
6782 if (!wxPyCheckForApp()) SWIG_fail;
6783 PyThreadState* __tstate = wxPyBeginAllowThreads();
6784 result = wxGetDisplaySize();
6785 wxPyEndAllowThreads(__tstate);
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6796 PyObject *resultobj = 0;
6797 int *arg1 = (int *) 0 ;
6798 int *arg2 = (int *) 0 ;
6799 int temp1 ;
6800 int res1 = SWIG_TMPOBJ ;
6801 int temp2 ;
6802 int res2 = SWIG_TMPOBJ ;
6803
6804 arg1 = &temp1;
6805 arg2 = &temp2;
6806 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6807 {
6808 if (!wxPyCheckForApp()) SWIG_fail;
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 wxDisplaySizeMM(arg1,arg2);
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 resultobj = SWIG_Py_Void();
6815 if (SWIG_IsTmpObj(res1)) {
6816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6817 } else {
6818 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6820 }
6821 if (SWIG_IsTmpObj(res2)) {
6822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6823 } else {
6824 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6826 }
6827 return resultobj;
6828 fail:
6829 return NULL;
6830 }
6831
6832
6833 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6834 PyObject *resultobj = 0;
6835 wxSize result;
6836
6837 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6838 {
6839 if (!wxPyCheckForApp()) SWIG_fail;
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = wxGetDisplaySizeMM();
6842 wxPyEndAllowThreads(__tstate);
6843 if (PyErr_Occurred()) SWIG_fail;
6844 }
6845 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6846 return resultobj;
6847 fail:
6848 return NULL;
6849 }
6850
6851
6852 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6853 PyObject *resultobj = 0;
6854 int *arg1 = (int *) 0 ;
6855 int *arg2 = (int *) 0 ;
6856 int *arg3 = (int *) 0 ;
6857 int *arg4 = (int *) 0 ;
6858 int temp1 ;
6859 int res1 = SWIG_TMPOBJ ;
6860 int temp2 ;
6861 int res2 = SWIG_TMPOBJ ;
6862 int temp3 ;
6863 int res3 = SWIG_TMPOBJ ;
6864 int temp4 ;
6865 int res4 = SWIG_TMPOBJ ;
6866
6867 arg1 = &temp1;
6868 arg2 = &temp2;
6869 arg3 = &temp3;
6870 arg4 = &temp4;
6871 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6872 {
6873 if (!wxPyCheckForApp()) SWIG_fail;
6874 PyThreadState* __tstate = wxPyBeginAllowThreads();
6875 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6876 wxPyEndAllowThreads(__tstate);
6877 if (PyErr_Occurred()) SWIG_fail;
6878 }
6879 resultobj = SWIG_Py_Void();
6880 if (SWIG_IsTmpObj(res1)) {
6881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6882 } else {
6883 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6885 }
6886 if (SWIG_IsTmpObj(res2)) {
6887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6888 } else {
6889 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6891 }
6892 if (SWIG_IsTmpObj(res3)) {
6893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6894 } else {
6895 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6897 }
6898 if (SWIG_IsTmpObj(res4)) {
6899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6900 } else {
6901 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6903 }
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6911 PyObject *resultobj = 0;
6912 wxRect result;
6913
6914 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6915 {
6916 if (!wxPyCheckForApp()) SWIG_fail;
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 result = wxGetClientDisplayRect();
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj = 0;
6931 wxCursor *arg1 = 0 ;
6932 void *argp1 = 0 ;
6933 int res1 = 0 ;
6934 PyObject * obj0 = 0 ;
6935 char * kwnames[] = {
6936 (char *) "cursor", NULL
6937 };
6938
6939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6940 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6941 if (!SWIG_IsOK(res1)) {
6942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6943 }
6944 if (!argp1) {
6945 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6946 }
6947 arg1 = reinterpret_cast< wxCursor * >(argp1);
6948 {
6949 if (!wxPyCheckForApp()) SWIG_fail;
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 wxSetCursor(*arg1);
6952 wxPyEndAllowThreads(__tstate);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 resultobj = SWIG_Py_Void();
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6963 PyObject *resultobj = 0;
6964 void *result = 0 ;
6965
6966 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6967 {
6968 if (!wxPyCheckForApp()) SWIG_fail;
6969 PyThreadState* __tstate = wxPyBeginAllowThreads();
6970 result = (void *)wxGetXDisplay();
6971 wxPyEndAllowThreads(__tstate);
6972 if (PyErr_Occurred()) SWIG_fail;
6973 }
6974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6975 return resultobj;
6976 fail:
6977 return NULL;
6978 }
6979
6980
6981 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6982 PyObject *resultobj = 0;
6983 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6984 void *argp1 = 0 ;
6985 int res1 = 0 ;
6986 PyObject * obj0 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "cursor", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6992 if (obj0) {
6993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6996 }
6997 arg1 = reinterpret_cast< wxCursor * >(argp1);
6998 }
6999 {
7000 if (!wxPyCheckForApp()) SWIG_fail;
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 wxBeginBusyCursor(arg1);
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_Py_Void();
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7014 PyObject *resultobj = 0;
7015 wxPoint result;
7016
7017 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7018 {
7019 if (!wxPyCheckForApp()) SWIG_fail;
7020 PyThreadState* __tstate = wxPyBeginAllowThreads();
7021 result = wxGetMousePosition();
7022 wxPyEndAllowThreads(__tstate);
7023 if (PyErr_Occurred()) SWIG_fail;
7024 }
7025 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7026 return resultobj;
7027 fail:
7028 return NULL;
7029 }
7030
7031
7032 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7033 PyObject *resultobj = 0;
7034 wxWindow *result = 0 ;
7035
7036 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7037 {
7038 if (!wxPyCheckForApp()) SWIG_fail;
7039 PyThreadState* __tstate = wxPyBeginAllowThreads();
7040 result = (wxWindow *)FindWindowAtPointer();
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 {
7045 resultobj = wxPyMake_wxObject(result, 0);
7046 }
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7054 PyObject *resultobj = 0;
7055 wxWindow *result = 0 ;
7056
7057 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7058 {
7059 if (!wxPyCheckForApp()) SWIG_fail;
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 result = (wxWindow *)wxGetActiveWindow();
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 {
7066 resultobj = wxPyMake_wxObject(result, 0);
7067 }
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7075 PyObject *resultobj = 0;
7076 wxPoint *arg1 = 0 ;
7077 wxWindow *result = 0 ;
7078 wxPoint temp1 ;
7079 PyObject * obj0 = 0 ;
7080 char * kwnames[] = {
7081 (char *) "pt", NULL
7082 };
7083
7084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7085 {
7086 arg1 = &temp1;
7087 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7088 }
7089 {
7090 if (!wxPyCheckForApp()) SWIG_fail;
7091 PyThreadState* __tstate = wxPyBeginAllowThreads();
7092 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7093 wxPyEndAllowThreads(__tstate);
7094 if (PyErr_Occurred()) SWIG_fail;
7095 }
7096 {
7097 resultobj = wxPyMake_wxObject(result, 0);
7098 }
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7106 PyObject *resultobj = 0;
7107 wxPoint *arg1 = 0 ;
7108 wxWindow *result = 0 ;
7109 wxPoint temp1 ;
7110 PyObject * obj0 = 0 ;
7111 char * kwnames[] = {
7112 (char *) "pt", NULL
7113 };
7114
7115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7116 {
7117 arg1 = &temp1;
7118 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7119 }
7120 {
7121 if (!wxPyCheckForApp()) SWIG_fail;
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 {
7128 resultobj = wxPyMake_wxObject(result, 0);
7129 }
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj = 0;
7138 wxWindow *arg1 = (wxWindow *) 0 ;
7139 wxWindow *result = 0 ;
7140 void *argp1 = 0 ;
7141 int res1 = 0 ;
7142 PyObject * obj0 = 0 ;
7143 char * kwnames[] = {
7144 (char *) "win", NULL
7145 };
7146
7147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7149 if (!SWIG_IsOK(res1)) {
7150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7151 }
7152 arg1 = reinterpret_cast< wxWindow * >(argp1);
7153 {
7154 if (!wxPyCheckForApp()) SWIG_fail;
7155 PyThreadState* __tstate = wxPyBeginAllowThreads();
7156 result = (wxWindow *)wxGetTopLevelParent(arg1);
7157 wxPyEndAllowThreads(__tstate);
7158 if (PyErr_Occurred()) SWIG_fail;
7159 }
7160 {
7161 resultobj = wxPyMake_wxObject(result, 0);
7162 }
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj = 0;
7171 wxString *arg1 = 0 ;
7172 bool result;
7173 bool temp1 = false ;
7174 PyObject * obj0 = 0 ;
7175 char * kwnames[] = {
7176 (char *) "url", NULL
7177 };
7178
7179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7180 {
7181 arg1 = wxString_in_helper(obj0);
7182 if (arg1 == NULL) SWIG_fail;
7183 temp1 = true;
7184 }
7185 {
7186 PyThreadState* __tstate = wxPyBeginAllowThreads();
7187 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7188 wxPyEndAllowThreads(__tstate);
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 {
7192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7193 }
7194 {
7195 if (temp1)
7196 delete arg1;
7197 }
7198 return resultobj;
7199 fail:
7200 {
7201 if (temp1)
7202 delete arg1;
7203 }
7204 return NULL;
7205 }
7206
7207
7208 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7209 PyObject *resultobj = 0;
7210 wxKeyCode arg1 ;
7211 bool result;
7212 int val1 ;
7213 int ecode1 = 0 ;
7214 PyObject * obj0 = 0 ;
7215 char * kwnames[] = {
7216 (char *) "key", NULL
7217 };
7218
7219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7220 ecode1 = SWIG_AsVal_int(obj0, &val1);
7221 if (!SWIG_IsOK(ecode1)) {
7222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7223 }
7224 arg1 = static_cast< wxKeyCode >(val1);
7225 {
7226 if (!wxPyCheckForApp()) SWIG_fail;
7227 PyThreadState* __tstate = wxPyBeginAllowThreads();
7228 result = (bool)wxGetKeyState(arg1);
7229 wxPyEndAllowThreads(__tstate);
7230 if (PyErr_Occurred()) SWIG_fail;
7231 }
7232 {
7233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7234 }
7235 return resultobj;
7236 fail:
7237 return NULL;
7238 }
7239
7240
7241 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7242 PyObject *resultobj = 0;
7243 wxMouseState *result = 0 ;
7244
7245 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7246 {
7247 PyThreadState* __tstate = wxPyBeginAllowThreads();
7248 result = (wxMouseState *)new wxMouseState();
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7260 PyObject *resultobj = 0;
7261 wxMouseState *arg1 = (wxMouseState *) 0 ;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 PyObject *swig_obj[1] ;
7265
7266 if (!args) SWIG_fail;
7267 swig_obj[0] = args;
7268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7269 if (!SWIG_IsOK(res1)) {
7270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7271 }
7272 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7273 {
7274 PyThreadState* __tstate = wxPyBeginAllowThreads();
7275 delete arg1;
7276
7277 wxPyEndAllowThreads(__tstate);
7278 if (PyErr_Occurred()) SWIG_fail;
7279 }
7280 resultobj = SWIG_Py_Void();
7281 return resultobj;
7282 fail:
7283 return NULL;
7284 }
7285
7286
7287 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7288 PyObject *resultobj = 0;
7289 wxMouseState *arg1 = (wxMouseState *) 0 ;
7290 int result;
7291 void *argp1 = 0 ;
7292 int res1 = 0 ;
7293 PyObject *swig_obj[1] ;
7294
7295 if (!args) SWIG_fail;
7296 swig_obj[0] = args;
7297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7298 if (!SWIG_IsOK(res1)) {
7299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7300 }
7301 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 result = (int)(arg1)->GetX();
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 resultobj = SWIG_From_int(static_cast< int >(result));
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7316 PyObject *resultobj = 0;
7317 wxMouseState *arg1 = (wxMouseState *) 0 ;
7318 int result;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 PyObject *swig_obj[1] ;
7322
7323 if (!args) SWIG_fail;
7324 swig_obj[0] = args;
7325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7328 }
7329 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7330 {
7331 PyThreadState* __tstate = wxPyBeginAllowThreads();
7332 result = (int)(arg1)->GetY();
7333 wxPyEndAllowThreads(__tstate);
7334 if (PyErr_Occurred()) SWIG_fail;
7335 }
7336 resultobj = SWIG_From_int(static_cast< int >(result));
7337 return resultobj;
7338 fail:
7339 return NULL;
7340 }
7341
7342
7343 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7344 PyObject *resultobj = 0;
7345 wxMouseState *arg1 = (wxMouseState *) 0 ;
7346 bool result;
7347 void *argp1 = 0 ;
7348 int res1 = 0 ;
7349 PyObject *swig_obj[1] ;
7350
7351 if (!args) SWIG_fail;
7352 swig_obj[0] = args;
7353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7354 if (!SWIG_IsOK(res1)) {
7355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7356 }
7357 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 result = (bool)(arg1)->LeftDown();
7361 wxPyEndAllowThreads(__tstate);
7362 if (PyErr_Occurred()) SWIG_fail;
7363 }
7364 {
7365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7366 }
7367 return resultobj;
7368 fail:
7369 return NULL;
7370 }
7371
7372
7373 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7374 PyObject *resultobj = 0;
7375 wxMouseState *arg1 = (wxMouseState *) 0 ;
7376 bool result;
7377 void *argp1 = 0 ;
7378 int res1 = 0 ;
7379 PyObject *swig_obj[1] ;
7380
7381 if (!args) SWIG_fail;
7382 swig_obj[0] = args;
7383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7384 if (!SWIG_IsOK(res1)) {
7385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7386 }
7387 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7388 {
7389 PyThreadState* __tstate = wxPyBeginAllowThreads();
7390 result = (bool)(arg1)->MiddleDown();
7391 wxPyEndAllowThreads(__tstate);
7392 if (PyErr_Occurred()) SWIG_fail;
7393 }
7394 {
7395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7396 }
7397 return resultobj;
7398 fail:
7399 return NULL;
7400 }
7401
7402
7403 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7404 PyObject *resultobj = 0;
7405 wxMouseState *arg1 = (wxMouseState *) 0 ;
7406 bool result;
7407 void *argp1 = 0 ;
7408 int res1 = 0 ;
7409 PyObject *swig_obj[1] ;
7410
7411 if (!args) SWIG_fail;
7412 swig_obj[0] = args;
7413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7416 }
7417 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 result = (bool)(arg1)->RightDown();
7421 wxPyEndAllowThreads(__tstate);
7422 if (PyErr_Occurred()) SWIG_fail;
7423 }
7424 {
7425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7426 }
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7434 PyObject *resultobj = 0;
7435 wxMouseState *arg1 = (wxMouseState *) 0 ;
7436 bool result;
7437 void *argp1 = 0 ;
7438 int res1 = 0 ;
7439 PyObject *swig_obj[1] ;
7440
7441 if (!args) SWIG_fail;
7442 swig_obj[0] = args;
7443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7444 if (!SWIG_IsOK(res1)) {
7445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7446 }
7447 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)(arg1)->ControlDown();
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7464 PyObject *resultobj = 0;
7465 wxMouseState *arg1 = (wxMouseState *) 0 ;
7466 bool result;
7467 void *argp1 = 0 ;
7468 int res1 = 0 ;
7469 PyObject *swig_obj[1] ;
7470
7471 if (!args) SWIG_fail;
7472 swig_obj[0] = args;
7473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7474 if (!SWIG_IsOK(res1)) {
7475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7476 }
7477 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7478 {
7479 PyThreadState* __tstate = wxPyBeginAllowThreads();
7480 result = (bool)(arg1)->ShiftDown();
7481 wxPyEndAllowThreads(__tstate);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7494 PyObject *resultobj = 0;
7495 wxMouseState *arg1 = (wxMouseState *) 0 ;
7496 bool result;
7497 void *argp1 = 0 ;
7498 int res1 = 0 ;
7499 PyObject *swig_obj[1] ;
7500
7501 if (!args) SWIG_fail;
7502 swig_obj[0] = args;
7503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7504 if (!SWIG_IsOK(res1)) {
7505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7506 }
7507 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7508 {
7509 PyThreadState* __tstate = wxPyBeginAllowThreads();
7510 result = (bool)(arg1)->AltDown();
7511 wxPyEndAllowThreads(__tstate);
7512 if (PyErr_Occurred()) SWIG_fail;
7513 }
7514 {
7515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7516 }
7517 return resultobj;
7518 fail:
7519 return NULL;
7520 }
7521
7522
7523 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7524 PyObject *resultobj = 0;
7525 wxMouseState *arg1 = (wxMouseState *) 0 ;
7526 bool result;
7527 void *argp1 = 0 ;
7528 int res1 = 0 ;
7529 PyObject *swig_obj[1] ;
7530
7531 if (!args) SWIG_fail;
7532 swig_obj[0] = args;
7533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7534 if (!SWIG_IsOK(res1)) {
7535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7536 }
7537 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7538 {
7539 PyThreadState* __tstate = wxPyBeginAllowThreads();
7540 result = (bool)(arg1)->MetaDown();
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 {
7545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7546 }
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7554 PyObject *resultobj = 0;
7555 wxMouseState *arg1 = (wxMouseState *) 0 ;
7556 bool result;
7557 void *argp1 = 0 ;
7558 int res1 = 0 ;
7559 PyObject *swig_obj[1] ;
7560
7561 if (!args) SWIG_fail;
7562 swig_obj[0] = args;
7563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7564 if (!SWIG_IsOK(res1)) {
7565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7566 }
7567 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7568 {
7569 PyThreadState* __tstate = wxPyBeginAllowThreads();
7570 result = (bool)(arg1)->CmdDown();
7571 wxPyEndAllowThreads(__tstate);
7572 if (PyErr_Occurred()) SWIG_fail;
7573 }
7574 {
7575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7576 }
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = 0;
7585 wxMouseState *arg1 = (wxMouseState *) 0 ;
7586 int arg2 ;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 int val2 ;
7590 int ecode2 = 0 ;
7591 PyObject * obj0 = 0 ;
7592 PyObject * obj1 = 0 ;
7593 char * kwnames[] = {
7594 (char *) "self",(char *) "x", NULL
7595 };
7596
7597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7599 if (!SWIG_IsOK(res1)) {
7600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7601 }
7602 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7603 ecode2 = SWIG_AsVal_int(obj1, &val2);
7604 if (!SWIG_IsOK(ecode2)) {
7605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7606 }
7607 arg2 = static_cast< int >(val2);
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 (arg1)->SetX(arg2);
7611 wxPyEndAllowThreads(__tstate);
7612 if (PyErr_Occurred()) SWIG_fail;
7613 }
7614 resultobj = SWIG_Py_Void();
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj = 0;
7623 wxMouseState *arg1 = (wxMouseState *) 0 ;
7624 int arg2 ;
7625 void *argp1 = 0 ;
7626 int res1 = 0 ;
7627 int val2 ;
7628 int ecode2 = 0 ;
7629 PyObject * obj0 = 0 ;
7630 PyObject * obj1 = 0 ;
7631 char * kwnames[] = {
7632 (char *) "self",(char *) "y", NULL
7633 };
7634
7635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7637 if (!SWIG_IsOK(res1)) {
7638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7639 }
7640 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7641 ecode2 = SWIG_AsVal_int(obj1, &val2);
7642 if (!SWIG_IsOK(ecode2)) {
7643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7644 }
7645 arg2 = static_cast< int >(val2);
7646 {
7647 PyThreadState* __tstate = wxPyBeginAllowThreads();
7648 (arg1)->SetY(arg2);
7649 wxPyEndAllowThreads(__tstate);
7650 if (PyErr_Occurred()) SWIG_fail;
7651 }
7652 resultobj = SWIG_Py_Void();
7653 return resultobj;
7654 fail:
7655 return NULL;
7656 }
7657
7658
7659 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7660 PyObject *resultobj = 0;
7661 wxMouseState *arg1 = (wxMouseState *) 0 ;
7662 bool arg2 ;
7663 void *argp1 = 0 ;
7664 int res1 = 0 ;
7665 bool val2 ;
7666 int ecode2 = 0 ;
7667 PyObject * obj0 = 0 ;
7668 PyObject * obj1 = 0 ;
7669 char * kwnames[] = {
7670 (char *) "self",(char *) "down", NULL
7671 };
7672
7673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7675 if (!SWIG_IsOK(res1)) {
7676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7677 }
7678 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7679 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7680 if (!SWIG_IsOK(ecode2)) {
7681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7682 }
7683 arg2 = static_cast< bool >(val2);
7684 {
7685 PyThreadState* __tstate = wxPyBeginAllowThreads();
7686 (arg1)->SetLeftDown(arg2);
7687 wxPyEndAllowThreads(__tstate);
7688 if (PyErr_Occurred()) SWIG_fail;
7689 }
7690 resultobj = SWIG_Py_Void();
7691 return resultobj;
7692 fail:
7693 return NULL;
7694 }
7695
7696
7697 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7698 PyObject *resultobj = 0;
7699 wxMouseState *arg1 = (wxMouseState *) 0 ;
7700 bool arg2 ;
7701 void *argp1 = 0 ;
7702 int res1 = 0 ;
7703 bool val2 ;
7704 int ecode2 = 0 ;
7705 PyObject * obj0 = 0 ;
7706 PyObject * obj1 = 0 ;
7707 char * kwnames[] = {
7708 (char *) "self",(char *) "down", NULL
7709 };
7710
7711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7713 if (!SWIG_IsOK(res1)) {
7714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7715 }
7716 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7717 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7718 if (!SWIG_IsOK(ecode2)) {
7719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7720 }
7721 arg2 = static_cast< bool >(val2);
7722 {
7723 PyThreadState* __tstate = wxPyBeginAllowThreads();
7724 (arg1)->SetMiddleDown(arg2);
7725 wxPyEndAllowThreads(__tstate);
7726 if (PyErr_Occurred()) SWIG_fail;
7727 }
7728 resultobj = SWIG_Py_Void();
7729 return resultobj;
7730 fail:
7731 return NULL;
7732 }
7733
7734
7735 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7736 PyObject *resultobj = 0;
7737 wxMouseState *arg1 = (wxMouseState *) 0 ;
7738 bool arg2 ;
7739 void *argp1 = 0 ;
7740 int res1 = 0 ;
7741 bool val2 ;
7742 int ecode2 = 0 ;
7743 PyObject * obj0 = 0 ;
7744 PyObject * obj1 = 0 ;
7745 char * kwnames[] = {
7746 (char *) "self",(char *) "down", NULL
7747 };
7748
7749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7751 if (!SWIG_IsOK(res1)) {
7752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7753 }
7754 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7756 if (!SWIG_IsOK(ecode2)) {
7757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7758 }
7759 arg2 = static_cast< bool >(val2);
7760 {
7761 PyThreadState* __tstate = wxPyBeginAllowThreads();
7762 (arg1)->SetRightDown(arg2);
7763 wxPyEndAllowThreads(__tstate);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 resultobj = SWIG_Py_Void();
7767 return resultobj;
7768 fail:
7769 return NULL;
7770 }
7771
7772
7773 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7774 PyObject *resultobj = 0;
7775 wxMouseState *arg1 = (wxMouseState *) 0 ;
7776 bool arg2 ;
7777 void *argp1 = 0 ;
7778 int res1 = 0 ;
7779 bool val2 ;
7780 int ecode2 = 0 ;
7781 PyObject * obj0 = 0 ;
7782 PyObject * obj1 = 0 ;
7783 char * kwnames[] = {
7784 (char *) "self",(char *) "down", NULL
7785 };
7786
7787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7789 if (!SWIG_IsOK(res1)) {
7790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7791 }
7792 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7793 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7794 if (!SWIG_IsOK(ecode2)) {
7795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7796 }
7797 arg2 = static_cast< bool >(val2);
7798 {
7799 PyThreadState* __tstate = wxPyBeginAllowThreads();
7800 (arg1)->SetControlDown(arg2);
7801 wxPyEndAllowThreads(__tstate);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 resultobj = SWIG_Py_Void();
7805 return resultobj;
7806 fail:
7807 return NULL;
7808 }
7809
7810
7811 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7812 PyObject *resultobj = 0;
7813 wxMouseState *arg1 = (wxMouseState *) 0 ;
7814 bool arg2 ;
7815 void *argp1 = 0 ;
7816 int res1 = 0 ;
7817 bool val2 ;
7818 int ecode2 = 0 ;
7819 PyObject * obj0 = 0 ;
7820 PyObject * obj1 = 0 ;
7821 char * kwnames[] = {
7822 (char *) "self",(char *) "down", NULL
7823 };
7824
7825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7827 if (!SWIG_IsOK(res1)) {
7828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7829 }
7830 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7831 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7832 if (!SWIG_IsOK(ecode2)) {
7833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7834 }
7835 arg2 = static_cast< bool >(val2);
7836 {
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 (arg1)->SetShiftDown(arg2);
7839 wxPyEndAllowThreads(__tstate);
7840 if (PyErr_Occurred()) SWIG_fail;
7841 }
7842 resultobj = SWIG_Py_Void();
7843 return resultobj;
7844 fail:
7845 return NULL;
7846 }
7847
7848
7849 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7850 PyObject *resultobj = 0;
7851 wxMouseState *arg1 = (wxMouseState *) 0 ;
7852 bool arg2 ;
7853 void *argp1 = 0 ;
7854 int res1 = 0 ;
7855 bool val2 ;
7856 int ecode2 = 0 ;
7857 PyObject * obj0 = 0 ;
7858 PyObject * obj1 = 0 ;
7859 char * kwnames[] = {
7860 (char *) "self",(char *) "down", NULL
7861 };
7862
7863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7865 if (!SWIG_IsOK(res1)) {
7866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7867 }
7868 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7870 if (!SWIG_IsOK(ecode2)) {
7871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7872 }
7873 arg2 = static_cast< bool >(val2);
7874 {
7875 PyThreadState* __tstate = wxPyBeginAllowThreads();
7876 (arg1)->SetAltDown(arg2);
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = SWIG_Py_Void();
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj = 0;
7889 wxMouseState *arg1 = (wxMouseState *) 0 ;
7890 bool arg2 ;
7891 void *argp1 = 0 ;
7892 int res1 = 0 ;
7893 bool val2 ;
7894 int ecode2 = 0 ;
7895 PyObject * obj0 = 0 ;
7896 PyObject * obj1 = 0 ;
7897 char * kwnames[] = {
7898 (char *) "self",(char *) "down", NULL
7899 };
7900
7901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7903 if (!SWIG_IsOK(res1)) {
7904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7905 }
7906 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7907 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7908 if (!SWIG_IsOK(ecode2)) {
7909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7910 }
7911 arg2 = static_cast< bool >(val2);
7912 {
7913 PyThreadState* __tstate = wxPyBeginAllowThreads();
7914 (arg1)->SetMetaDown(arg2);
7915 wxPyEndAllowThreads(__tstate);
7916 if (PyErr_Occurred()) SWIG_fail;
7917 }
7918 resultobj = SWIG_Py_Void();
7919 return resultobj;
7920 fail:
7921 return NULL;
7922 }
7923
7924
7925 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7926 PyObject *obj;
7927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7928 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7929 return SWIG_Py_Void();
7930 }
7931
7932 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7933 return SWIG_Python_InitShadowInstance(args);
7934 }
7935
7936 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7937 PyObject *resultobj = 0;
7938 wxMouseState result;
7939
7940 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7941 {
7942 PyThreadState* __tstate = wxPyBeginAllowThreads();
7943 result = wxGetMouseState();
7944 wxPyEndAllowThreads(__tstate);
7945 if (PyErr_Occurred()) SWIG_fail;
7946 }
7947 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7948 return resultobj;
7949 fail:
7950 return NULL;
7951 }
7952
7953
7954 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7955 PyObject *resultobj = 0;
7956
7957 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7958 {
7959 if (!wxPyCheckForApp()) SWIG_fail;
7960 PyThreadState* __tstate = wxPyBeginAllowThreads();
7961 wxWakeUpMainThread();
7962 wxPyEndAllowThreads(__tstate);
7963 if (PyErr_Occurred()) SWIG_fail;
7964 }
7965 resultobj = SWIG_Py_Void();
7966 return resultobj;
7967 fail:
7968 return NULL;
7969 }
7970
7971
7972 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7973 PyObject *resultobj = 0;
7974
7975 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7976 {
7977 if (!wxPyCheckForApp()) SWIG_fail;
7978 PyThreadState* __tstate = wxPyBeginAllowThreads();
7979 wxMutexGuiEnter();
7980 wxPyEndAllowThreads(__tstate);
7981 if (PyErr_Occurred()) SWIG_fail;
7982 }
7983 resultobj = SWIG_Py_Void();
7984 return resultobj;
7985 fail:
7986 return NULL;
7987 }
7988
7989
7990 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7991 PyObject *resultobj = 0;
7992
7993 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7994 {
7995 if (!wxPyCheckForApp()) SWIG_fail;
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 wxMutexGuiLeave();
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 resultobj = SWIG_Py_Void();
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8009 PyObject *resultobj = 0;
8010 wxMutexGuiLocker *result = 0 ;
8011
8012 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8013 {
8014 if (!wxPyCheckForApp()) SWIG_fail;
8015 PyThreadState* __tstate = wxPyBeginAllowThreads();
8016 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8017 wxPyEndAllowThreads(__tstate);
8018 if (PyErr_Occurred()) SWIG_fail;
8019 }
8020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8021 return resultobj;
8022 fail:
8023 return NULL;
8024 }
8025
8026
8027 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8028 PyObject *resultobj = 0;
8029 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8030 void *argp1 = 0 ;
8031 int res1 = 0 ;
8032 PyObject *swig_obj[1] ;
8033
8034 if (!args) SWIG_fail;
8035 swig_obj[0] = args;
8036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8037 if (!SWIG_IsOK(res1)) {
8038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8039 }
8040 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8041 {
8042 PyThreadState* __tstate = wxPyBeginAllowThreads();
8043 delete arg1;
8044
8045 wxPyEndAllowThreads(__tstate);
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 resultobj = SWIG_Py_Void();
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8056 PyObject *obj;
8057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8058 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8059 return SWIG_Py_Void();
8060 }
8061
8062 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8063 return SWIG_Python_InitShadowInstance(args);
8064 }
8065
8066 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8067 PyObject *resultobj = 0;
8068 bool result;
8069
8070 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8071 {
8072 PyThreadState* __tstate = wxPyBeginAllowThreads();
8073 result = (bool)wxThread_IsMain();
8074 wxPyEndAllowThreads(__tstate);
8075 if (PyErr_Occurred()) SWIG_fail;
8076 }
8077 {
8078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8079 }
8080 return resultobj;
8081 fail:
8082 return NULL;
8083 }
8084
8085
8086 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8087 PyObject *resultobj = 0;
8088 wxString *arg1 = 0 ;
8089 wxToolTip *result = 0 ;
8090 bool temp1 = false ;
8091 PyObject * obj0 = 0 ;
8092 char * kwnames[] = {
8093 (char *) "tip", NULL
8094 };
8095
8096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8097 {
8098 arg1 = wxString_in_helper(obj0);
8099 if (arg1 == NULL) SWIG_fail;
8100 temp1 = true;
8101 }
8102 {
8103 if (!wxPyCheckForApp()) SWIG_fail;
8104 PyThreadState* __tstate = wxPyBeginAllowThreads();
8105 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8106 wxPyEndAllowThreads(__tstate);
8107 if (PyErr_Occurred()) SWIG_fail;
8108 }
8109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8110 {
8111 if (temp1)
8112 delete arg1;
8113 }
8114 return resultobj;
8115 fail:
8116 {
8117 if (temp1)
8118 delete arg1;
8119 }
8120 return NULL;
8121 }
8122
8123
8124 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8125 PyObject *resultobj = 0;
8126 wxToolTip *arg1 = (wxToolTip *) 0 ;
8127 void *argp1 = 0 ;
8128 int res1 = 0 ;
8129 PyObject *swig_obj[1] ;
8130
8131 if (!args) SWIG_fail;
8132 swig_obj[0] = args;
8133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8134 if (!SWIG_IsOK(res1)) {
8135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8136 }
8137 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8138 {
8139 PyThreadState* __tstate = wxPyBeginAllowThreads();
8140 delete arg1;
8141
8142 wxPyEndAllowThreads(__tstate);
8143 if (PyErr_Occurred()) SWIG_fail;
8144 }
8145 resultobj = SWIG_Py_Void();
8146 return resultobj;
8147 fail:
8148 return NULL;
8149 }
8150
8151
8152 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8153 PyObject *resultobj = 0;
8154 wxToolTip *arg1 = (wxToolTip *) 0 ;
8155 wxString *arg2 = 0 ;
8156 void *argp1 = 0 ;
8157 int res1 = 0 ;
8158 bool temp2 = false ;
8159 PyObject * obj0 = 0 ;
8160 PyObject * obj1 = 0 ;
8161 char * kwnames[] = {
8162 (char *) "self",(char *) "tip", NULL
8163 };
8164
8165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8167 if (!SWIG_IsOK(res1)) {
8168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8169 }
8170 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8171 {
8172 arg2 = wxString_in_helper(obj1);
8173 if (arg2 == NULL) SWIG_fail;
8174 temp2 = true;
8175 }
8176 {
8177 PyThreadState* __tstate = wxPyBeginAllowThreads();
8178 (arg1)->SetTip((wxString const &)*arg2);
8179 wxPyEndAllowThreads(__tstate);
8180 if (PyErr_Occurred()) SWIG_fail;
8181 }
8182 resultobj = SWIG_Py_Void();
8183 {
8184 if (temp2)
8185 delete arg2;
8186 }
8187 return resultobj;
8188 fail:
8189 {
8190 if (temp2)
8191 delete arg2;
8192 }
8193 return NULL;
8194 }
8195
8196
8197 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8198 PyObject *resultobj = 0;
8199 wxToolTip *arg1 = (wxToolTip *) 0 ;
8200 wxString result;
8201 void *argp1 = 0 ;
8202 int res1 = 0 ;
8203 PyObject *swig_obj[1] ;
8204
8205 if (!args) SWIG_fail;
8206 swig_obj[0] = args;
8207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8208 if (!SWIG_IsOK(res1)) {
8209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8210 }
8211 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8212 {
8213 PyThreadState* __tstate = wxPyBeginAllowThreads();
8214 result = (arg1)->GetTip();
8215 wxPyEndAllowThreads(__tstate);
8216 if (PyErr_Occurred()) SWIG_fail;
8217 }
8218 {
8219 #if wxUSE_UNICODE
8220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8221 #else
8222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8223 #endif
8224 }
8225 return resultobj;
8226 fail:
8227 return NULL;
8228 }
8229
8230
8231 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8232 PyObject *resultobj = 0;
8233 wxToolTip *arg1 = (wxToolTip *) 0 ;
8234 wxWindow *result = 0 ;
8235 void *argp1 = 0 ;
8236 int res1 = 0 ;
8237 PyObject *swig_obj[1] ;
8238
8239 if (!args) SWIG_fail;
8240 swig_obj[0] = args;
8241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8242 if (!SWIG_IsOK(res1)) {
8243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8244 }
8245 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 result = (wxWindow *)(arg1)->GetWindow();
8249 wxPyEndAllowThreads(__tstate);
8250 if (PyErr_Occurred()) SWIG_fail;
8251 }
8252 {
8253 resultobj = wxPyMake_wxObject(result, 0);
8254 }
8255 return resultobj;
8256 fail:
8257 return NULL;
8258 }
8259
8260
8261 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8262 PyObject *resultobj = 0;
8263 bool arg1 ;
8264 bool val1 ;
8265 int ecode1 = 0 ;
8266 PyObject * obj0 = 0 ;
8267 char * kwnames[] = {
8268 (char *) "flag", NULL
8269 };
8270
8271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8272 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8273 if (!SWIG_IsOK(ecode1)) {
8274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8275 }
8276 arg1 = static_cast< bool >(val1);
8277 {
8278 PyThreadState* __tstate = wxPyBeginAllowThreads();
8279 wxToolTip::Enable(arg1);
8280 wxPyEndAllowThreads(__tstate);
8281 if (PyErr_Occurred()) SWIG_fail;
8282 }
8283 resultobj = SWIG_Py_Void();
8284 return resultobj;
8285 fail:
8286 return NULL;
8287 }
8288
8289
8290 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8291 PyObject *resultobj = 0;
8292 long arg1 ;
8293 long val1 ;
8294 int ecode1 = 0 ;
8295 PyObject * obj0 = 0 ;
8296 char * kwnames[] = {
8297 (char *) "milliseconds", NULL
8298 };
8299
8300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8301 ecode1 = SWIG_AsVal_long(obj0, &val1);
8302 if (!SWIG_IsOK(ecode1)) {
8303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8304 }
8305 arg1 = static_cast< long >(val1);
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 wxToolTip::SetDelay(arg1);
8309 wxPyEndAllowThreads(__tstate);
8310 if (PyErr_Occurred()) SWIG_fail;
8311 }
8312 resultobj = SWIG_Py_Void();
8313 return resultobj;
8314 fail:
8315 return NULL;
8316 }
8317
8318
8319 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8320 PyObject *obj;
8321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8322 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8323 return SWIG_Py_Void();
8324 }
8325
8326 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8327 return SWIG_Python_InitShadowInstance(args);
8328 }
8329
8330 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8331 PyObject *resultobj = 0;
8332 wxWindow *arg1 = (wxWindow *) 0 ;
8333 wxSize *arg2 = 0 ;
8334 wxCaret *result = 0 ;
8335 void *argp1 = 0 ;
8336 int res1 = 0 ;
8337 wxSize temp2 ;
8338 PyObject * obj0 = 0 ;
8339 PyObject * obj1 = 0 ;
8340 char * kwnames[] = {
8341 (char *) "window",(char *) "size", NULL
8342 };
8343
8344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8346 if (!SWIG_IsOK(res1)) {
8347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8348 }
8349 arg1 = reinterpret_cast< wxWindow * >(argp1);
8350 {
8351 arg2 = &temp2;
8352 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8353 }
8354 {
8355 if (!wxPyCheckForApp()) SWIG_fail;
8356 PyThreadState* __tstate = wxPyBeginAllowThreads();
8357 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8369 PyObject *resultobj = 0;
8370 wxCaret *arg1 = (wxCaret *) 0 ;
8371 void *argp1 = 0 ;
8372 int res1 = 0 ;
8373 PyObject *swig_obj[1] ;
8374
8375 if (!args) SWIG_fail;
8376 swig_obj[0] = args;
8377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8378 if (!SWIG_IsOK(res1)) {
8379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8380 }
8381 arg1 = reinterpret_cast< wxCaret * >(argp1);
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 delete arg1;
8385
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 resultobj = SWIG_Py_Void();
8390 return resultobj;
8391 fail:
8392 return NULL;
8393 }
8394
8395
8396 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8397 PyObject *resultobj = 0;
8398 wxCaret *arg1 = (wxCaret *) 0 ;
8399 void *argp1 = 0 ;
8400 int res1 = 0 ;
8401 PyObject *swig_obj[1] ;
8402
8403 if (!args) SWIG_fail;
8404 swig_obj[0] = args;
8405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8406 if (!SWIG_IsOK(res1)) {
8407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8408 }
8409 arg1 = reinterpret_cast< wxCaret * >(argp1);
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 wxCaret_Destroy(arg1);
8413 wxPyEndAllowThreads(__tstate);
8414 if (PyErr_Occurred()) SWIG_fail;
8415 }
8416 resultobj = SWIG_Py_Void();
8417 return resultobj;
8418 fail:
8419 return NULL;
8420 }
8421
8422
8423 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8424 PyObject *resultobj = 0;
8425 wxCaret *arg1 = (wxCaret *) 0 ;
8426 bool result;
8427 void *argp1 = 0 ;
8428 int res1 = 0 ;
8429 PyObject *swig_obj[1] ;
8430
8431 if (!args) SWIG_fail;
8432 swig_obj[0] = args;
8433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8434 if (!SWIG_IsOK(res1)) {
8435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8436 }
8437 arg1 = reinterpret_cast< wxCaret * >(argp1);
8438 {
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (bool)(arg1)->IsOk();
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8446 }
8447 return resultobj;
8448 fail:
8449 return NULL;
8450 }
8451
8452
8453 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8454 PyObject *resultobj = 0;
8455 wxCaret *arg1 = (wxCaret *) 0 ;
8456 bool result;
8457 void *argp1 = 0 ;
8458 int res1 = 0 ;
8459 PyObject *swig_obj[1] ;
8460
8461 if (!args) SWIG_fail;
8462 swig_obj[0] = args;
8463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8464 if (!SWIG_IsOK(res1)) {
8465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8466 }
8467 arg1 = reinterpret_cast< wxCaret * >(argp1);
8468 {
8469 PyThreadState* __tstate = wxPyBeginAllowThreads();
8470 result = (bool)(arg1)->IsVisible();
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 {
8475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8476 }
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8484 PyObject *resultobj = 0;
8485 wxCaret *arg1 = (wxCaret *) 0 ;
8486 wxPoint result;
8487 void *argp1 = 0 ;
8488 int res1 = 0 ;
8489 PyObject *swig_obj[1] ;
8490
8491 if (!args) SWIG_fail;
8492 swig_obj[0] = args;
8493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8494 if (!SWIG_IsOK(res1)) {
8495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8496 }
8497 arg1 = reinterpret_cast< wxCaret * >(argp1);
8498 {
8499 PyThreadState* __tstate = wxPyBeginAllowThreads();
8500 result = (arg1)->GetPosition();
8501 wxPyEndAllowThreads(__tstate);
8502 if (PyErr_Occurred()) SWIG_fail;
8503 }
8504 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8505 return resultobj;
8506 fail:
8507 return NULL;
8508 }
8509
8510
8511 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8512 PyObject *resultobj = 0;
8513 wxCaret *arg1 = (wxCaret *) 0 ;
8514 int *arg2 = (int *) 0 ;
8515 int *arg3 = (int *) 0 ;
8516 void *argp1 = 0 ;
8517 int res1 = 0 ;
8518 int temp2 ;
8519 int res2 = SWIG_TMPOBJ ;
8520 int temp3 ;
8521 int res3 = SWIG_TMPOBJ ;
8522 PyObject *swig_obj[1] ;
8523
8524 arg2 = &temp2;
8525 arg3 = &temp3;
8526 if (!args) SWIG_fail;
8527 swig_obj[0] = args;
8528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8529 if (!SWIG_IsOK(res1)) {
8530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8531 }
8532 arg1 = reinterpret_cast< wxCaret * >(argp1);
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 (arg1)->GetPosition(arg2,arg3);
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_Py_Void();
8540 if (SWIG_IsTmpObj(res2)) {
8541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8542 } else {
8543 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8545 }
8546 if (SWIG_IsTmpObj(res3)) {
8547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8548 } else {
8549 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8551 }
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8559 PyObject *resultobj = 0;
8560 wxCaret *arg1 = (wxCaret *) 0 ;
8561 wxSize result;
8562 void *argp1 = 0 ;
8563 int res1 = 0 ;
8564 PyObject *swig_obj[1] ;
8565
8566 if (!args) SWIG_fail;
8567 swig_obj[0] = args;
8568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8569 if (!SWIG_IsOK(res1)) {
8570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8571 }
8572 arg1 = reinterpret_cast< wxCaret * >(argp1);
8573 {
8574 PyThreadState* __tstate = wxPyBeginAllowThreads();
8575 result = (arg1)->GetSize();
8576 wxPyEndAllowThreads(__tstate);
8577 if (PyErr_Occurred()) SWIG_fail;
8578 }
8579 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8580 return resultobj;
8581 fail:
8582 return NULL;
8583 }
8584
8585
8586 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8587 PyObject *resultobj = 0;
8588 wxCaret *arg1 = (wxCaret *) 0 ;
8589 int *arg2 = (int *) 0 ;
8590 int *arg3 = (int *) 0 ;
8591 void *argp1 = 0 ;
8592 int res1 = 0 ;
8593 int temp2 ;
8594 int res2 = SWIG_TMPOBJ ;
8595 int temp3 ;
8596 int res3 = SWIG_TMPOBJ ;
8597 PyObject *swig_obj[1] ;
8598
8599 arg2 = &temp2;
8600 arg3 = &temp3;
8601 if (!args) SWIG_fail;
8602 swig_obj[0] = args;
8603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8604 if (!SWIG_IsOK(res1)) {
8605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8606 }
8607 arg1 = reinterpret_cast< wxCaret * >(argp1);
8608 {
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 (arg1)->GetSize(arg2,arg3);
8611 wxPyEndAllowThreads(__tstate);
8612 if (PyErr_Occurred()) SWIG_fail;
8613 }
8614 resultobj = SWIG_Py_Void();
8615 if (SWIG_IsTmpObj(res2)) {
8616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8617 } else {
8618 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8620 }
8621 if (SWIG_IsTmpObj(res3)) {
8622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8623 } else {
8624 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8626 }
8627 return resultobj;
8628 fail:
8629 return NULL;
8630 }
8631
8632
8633 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8634 PyObject *resultobj = 0;
8635 wxCaret *arg1 = (wxCaret *) 0 ;
8636 wxWindow *result = 0 ;
8637 void *argp1 = 0 ;
8638 int res1 = 0 ;
8639 PyObject *swig_obj[1] ;
8640
8641 if (!args) SWIG_fail;
8642 swig_obj[0] = args;
8643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8644 if (!SWIG_IsOK(res1)) {
8645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8646 }
8647 arg1 = reinterpret_cast< wxCaret * >(argp1);
8648 {
8649 PyThreadState* __tstate = wxPyBeginAllowThreads();
8650 result = (wxWindow *)(arg1)->GetWindow();
8651 wxPyEndAllowThreads(__tstate);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 {
8655 resultobj = wxPyMake_wxObject(result, 0);
8656 }
8657 return resultobj;
8658 fail:
8659 return NULL;
8660 }
8661
8662
8663 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8664 PyObject *resultobj = 0;
8665 wxCaret *arg1 = (wxCaret *) 0 ;
8666 int arg2 ;
8667 int arg3 ;
8668 void *argp1 = 0 ;
8669 int res1 = 0 ;
8670 int val2 ;
8671 int ecode2 = 0 ;
8672 int val3 ;
8673 int ecode3 = 0 ;
8674 PyObject * obj0 = 0 ;
8675 PyObject * obj1 = 0 ;
8676 PyObject * obj2 = 0 ;
8677 char * kwnames[] = {
8678 (char *) "self",(char *) "x",(char *) "y", NULL
8679 };
8680
8681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8683 if (!SWIG_IsOK(res1)) {
8684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8685 }
8686 arg1 = reinterpret_cast< wxCaret * >(argp1);
8687 ecode2 = SWIG_AsVal_int(obj1, &val2);
8688 if (!SWIG_IsOK(ecode2)) {
8689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8690 }
8691 arg2 = static_cast< int >(val2);
8692 ecode3 = SWIG_AsVal_int(obj2, &val3);
8693 if (!SWIG_IsOK(ecode3)) {
8694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8695 }
8696 arg3 = static_cast< int >(val3);
8697 {
8698 PyThreadState* __tstate = wxPyBeginAllowThreads();
8699 (arg1)->Move(arg2,arg3);
8700 wxPyEndAllowThreads(__tstate);
8701 if (PyErr_Occurred()) SWIG_fail;
8702 }
8703 resultobj = SWIG_Py_Void();
8704 return resultobj;
8705 fail:
8706 return NULL;
8707 }
8708
8709
8710 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8711 PyObject *resultobj = 0;
8712 wxCaret *arg1 = (wxCaret *) 0 ;
8713 wxPoint *arg2 = 0 ;
8714 void *argp1 = 0 ;
8715 int res1 = 0 ;
8716 wxPoint temp2 ;
8717 PyObject * obj0 = 0 ;
8718 PyObject * obj1 = 0 ;
8719 char * kwnames[] = {
8720 (char *) "self",(char *) "pt", NULL
8721 };
8722
8723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8727 }
8728 arg1 = reinterpret_cast< wxCaret * >(argp1);
8729 {
8730 arg2 = &temp2;
8731 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8732 }
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 (arg1)->Move((wxPoint const &)*arg2);
8736 wxPyEndAllowThreads(__tstate);
8737 if (PyErr_Occurred()) SWIG_fail;
8738 }
8739 resultobj = SWIG_Py_Void();
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj = 0;
8748 wxCaret *arg1 = (wxCaret *) 0 ;
8749 int arg2 ;
8750 int arg3 ;
8751 void *argp1 = 0 ;
8752 int res1 = 0 ;
8753 int val2 ;
8754 int ecode2 = 0 ;
8755 int val3 ;
8756 int ecode3 = 0 ;
8757 PyObject * obj0 = 0 ;
8758 PyObject * obj1 = 0 ;
8759 PyObject * obj2 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "width",(char *) "height", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8768 }
8769 arg1 = reinterpret_cast< wxCaret * >(argp1);
8770 ecode2 = SWIG_AsVal_int(obj1, &val2);
8771 if (!SWIG_IsOK(ecode2)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8773 }
8774 arg2 = static_cast< int >(val2);
8775 ecode3 = SWIG_AsVal_int(obj2, &val3);
8776 if (!SWIG_IsOK(ecode3)) {
8777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8778 }
8779 arg3 = static_cast< int >(val3);
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 (arg1)->SetSize(arg2,arg3);
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_Py_Void();
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj = 0;
8795 wxCaret *arg1 = (wxCaret *) 0 ;
8796 wxSize *arg2 = 0 ;
8797 void *argp1 = 0 ;
8798 int res1 = 0 ;
8799 wxSize temp2 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "size", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8810 }
8811 arg1 = reinterpret_cast< wxCaret * >(argp1);
8812 {
8813 arg2 = &temp2;
8814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8815 }
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 (arg1)->SetSize((wxSize const &)*arg2);
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj = 0;
8831 wxCaret *arg1 = (wxCaret *) 0 ;
8832 int arg2 = (int) true ;
8833 void *argp1 = 0 ;
8834 int res1 = 0 ;
8835 int val2 ;
8836 int ecode2 = 0 ;
8837 PyObject * obj0 = 0 ;
8838 PyObject * obj1 = 0 ;
8839 char * kwnames[] = {
8840 (char *) "self",(char *) "show", NULL
8841 };
8842
8843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8845 if (!SWIG_IsOK(res1)) {
8846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8847 }
8848 arg1 = reinterpret_cast< wxCaret * >(argp1);
8849 if (obj1) {
8850 ecode2 = SWIG_AsVal_int(obj1, &val2);
8851 if (!SWIG_IsOK(ecode2)) {
8852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8853 }
8854 arg2 = static_cast< int >(val2);
8855 }
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 (arg1)->Show(arg2);
8859 wxPyEndAllowThreads(__tstate);
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = SWIG_Py_Void();
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8870 PyObject *resultobj = 0;
8871 wxCaret *arg1 = (wxCaret *) 0 ;
8872 void *argp1 = 0 ;
8873 int res1 = 0 ;
8874 PyObject *swig_obj[1] ;
8875
8876 if (!args) SWIG_fail;
8877 swig_obj[0] = args;
8878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8879 if (!SWIG_IsOK(res1)) {
8880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8881 }
8882 arg1 = reinterpret_cast< wxCaret * >(argp1);
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 (arg1)->Hide();
8886 wxPyEndAllowThreads(__tstate);
8887 if (PyErr_Occurred()) SWIG_fail;
8888 }
8889 resultobj = SWIG_Py_Void();
8890 return resultobj;
8891 fail:
8892 return NULL;
8893 }
8894
8895
8896 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8897 PyObject *resultobj = 0;
8898 int result;
8899
8900 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8901 {
8902 PyThreadState* __tstate = wxPyBeginAllowThreads();
8903 result = (int)wxCaret::GetBlinkTime();
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 resultobj = SWIG_From_int(static_cast< int >(result));
8908 return resultobj;
8909 fail:
8910 return NULL;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj = 0;
8916 int arg1 ;
8917 int val1 ;
8918 int ecode1 = 0 ;
8919 PyObject * obj0 = 0 ;
8920 char * kwnames[] = {
8921 (char *) "milliseconds", NULL
8922 };
8923
8924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8925 ecode1 = SWIG_AsVal_int(obj0, &val1);
8926 if (!SWIG_IsOK(ecode1)) {
8927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8928 }
8929 arg1 = static_cast< int >(val1);
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 wxCaret::SetBlinkTime(arg1);
8933 wxPyEndAllowThreads(__tstate);
8934 if (PyErr_Occurred()) SWIG_fail;
8935 }
8936 resultobj = SWIG_Py_Void();
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8944 PyObject *obj;
8945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8946 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8947 return SWIG_Py_Void();
8948 }
8949
8950 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951 return SWIG_Python_InitShadowInstance(args);
8952 }
8953
8954 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj = 0;
8956 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8957 wxBusyCursor *result = 0 ;
8958 void *argp1 = 0 ;
8959 int res1 = 0 ;
8960 PyObject * obj0 = 0 ;
8961 char * kwnames[] = {
8962 (char *) "cursor", NULL
8963 };
8964
8965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8966 if (obj0) {
8967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8970 }
8971 arg1 = reinterpret_cast< wxCursor * >(argp1);
8972 }
8973 {
8974 if (!wxPyCheckForApp()) SWIG_fail;
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8977 wxPyEndAllowThreads(__tstate);
8978 if (PyErr_Occurred()) SWIG_fail;
8979 }
8980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8981 return resultobj;
8982 fail:
8983 return NULL;
8984 }
8985
8986
8987 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8988 PyObject *resultobj = 0;
8989 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject *swig_obj[1] ;
8993
8994 if (!args) SWIG_fail;
8995 swig_obj[0] = args;
8996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8997 if (!SWIG_IsOK(res1)) {
8998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8999 }
9000 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 delete arg1;
9004
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 resultobj = SWIG_Py_Void();
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9016 PyObject *obj;
9017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9018 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9019 return SWIG_Py_Void();
9020 }
9021
9022 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9023 return SWIG_Python_InitShadowInstance(args);
9024 }
9025
9026 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9027 PyObject *resultobj = 0;
9028 wxWindow *arg1 = (wxWindow *) NULL ;
9029 wxWindowDisabler *result = 0 ;
9030 void *argp1 = 0 ;
9031 int res1 = 0 ;
9032 PyObject * obj0 = 0 ;
9033 char * kwnames[] = {
9034 (char *) "winToSkip", NULL
9035 };
9036
9037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9038 if (obj0) {
9039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9040 if (!SWIG_IsOK(res1)) {
9041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9042 }
9043 arg1 = reinterpret_cast< wxWindow * >(argp1);
9044 }
9045 {
9046 if (!wxPyCheckForApp()) SWIG_fail;
9047 PyThreadState* __tstate = wxPyBeginAllowThreads();
9048 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9049 wxPyEndAllowThreads(__tstate);
9050 if (PyErr_Occurred()) SWIG_fail;
9051 }
9052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9053 return resultobj;
9054 fail:
9055 return NULL;
9056 }
9057
9058
9059 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9060 PyObject *resultobj = 0;
9061 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9062 void *argp1 = 0 ;
9063 int res1 = 0 ;
9064 PyObject *swig_obj[1] ;
9065
9066 if (!args) SWIG_fail;
9067 swig_obj[0] = args;
9068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9069 if (!SWIG_IsOK(res1)) {
9070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9071 }
9072 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9073 {
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 delete arg1;
9076
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_Py_Void();
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *obj;
9089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9090 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9091 return SWIG_Py_Void();
9092 }
9093
9094 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 return SWIG_Python_InitShadowInstance(args);
9096 }
9097
9098 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9099 PyObject *resultobj = 0;
9100 wxString *arg1 = 0 ;
9101 wxBusyInfo *result = 0 ;
9102 bool temp1 = false ;
9103 PyObject * obj0 = 0 ;
9104 char * kwnames[] = {
9105 (char *) "message", NULL
9106 };
9107
9108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9109 {
9110 arg1 = wxString_in_helper(obj0);
9111 if (arg1 == NULL) SWIG_fail;
9112 temp1 = true;
9113 }
9114 {
9115 if (!wxPyCheckForApp()) SWIG_fail;
9116 PyThreadState* __tstate = wxPyBeginAllowThreads();
9117 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9118 wxPyEndAllowThreads(__tstate);
9119 if (PyErr_Occurred()) SWIG_fail;
9120 }
9121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9122 {
9123 if (temp1)
9124 delete arg1;
9125 }
9126 return resultobj;
9127 fail:
9128 {
9129 if (temp1)
9130 delete arg1;
9131 }
9132 return NULL;
9133 }
9134
9135
9136 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9137 PyObject *resultobj = 0;
9138 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9139 void *argp1 = 0 ;
9140 int res1 = 0 ;
9141 PyObject *swig_obj[1] ;
9142
9143 if (!args) SWIG_fail;
9144 swig_obj[0] = args;
9145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9146 if (!SWIG_IsOK(res1)) {
9147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9148 }
9149 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9150 {
9151 PyThreadState* __tstate = wxPyBeginAllowThreads();
9152 delete arg1;
9153
9154 wxPyEndAllowThreads(__tstate);
9155 if (PyErr_Occurred()) SWIG_fail;
9156 }
9157 resultobj = SWIG_Py_Void();
9158 return resultobj;
9159 fail:
9160 return NULL;
9161 }
9162
9163
9164 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9165 PyObject *obj;
9166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9167 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9168 return SWIG_Py_Void();
9169 }
9170
9171 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9172 return SWIG_Python_InitShadowInstance(args);
9173 }
9174
9175 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9176 PyObject *resultobj = 0;
9177 wxStopWatch *result = 0 ;
9178
9179 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 result = (wxStopWatch *)new wxStopWatch();
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9187 return resultobj;
9188 fail:
9189 return NULL;
9190 }
9191
9192
9193 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9194 PyObject *resultobj = 0;
9195 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9196 long arg2 = (long) 0 ;
9197 void *argp1 = 0 ;
9198 int res1 = 0 ;
9199 long val2 ;
9200 int ecode2 = 0 ;
9201 PyObject * obj0 = 0 ;
9202 PyObject * obj1 = 0 ;
9203 char * kwnames[] = {
9204 (char *) "self",(char *) "t0", NULL
9205 };
9206
9207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9209 if (!SWIG_IsOK(res1)) {
9210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9211 }
9212 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9213 if (obj1) {
9214 ecode2 = SWIG_AsVal_long(obj1, &val2);
9215 if (!SWIG_IsOK(ecode2)) {
9216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9217 }
9218 arg2 = static_cast< long >(val2);
9219 }
9220 {
9221 PyThreadState* __tstate = wxPyBeginAllowThreads();
9222 (arg1)->Start(arg2);
9223 wxPyEndAllowThreads(__tstate);
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 resultobj = SWIG_Py_Void();
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234 PyObject *resultobj = 0;
9235 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9236 void *argp1 = 0 ;
9237 int res1 = 0 ;
9238 PyObject *swig_obj[1] ;
9239
9240 if (!args) SWIG_fail;
9241 swig_obj[0] = args;
9242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9245 }
9246 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9247 {
9248 PyThreadState* __tstate = wxPyBeginAllowThreads();
9249 (arg1)->Pause();
9250 wxPyEndAllowThreads(__tstate);
9251 if (PyErr_Occurred()) SWIG_fail;
9252 }
9253 resultobj = SWIG_Py_Void();
9254 return resultobj;
9255 fail:
9256 return NULL;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9261 PyObject *resultobj = 0;
9262 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9263 void *argp1 = 0 ;
9264 int res1 = 0 ;
9265 PyObject *swig_obj[1] ;
9266
9267 if (!args) SWIG_fail;
9268 swig_obj[0] = args;
9269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9270 if (!SWIG_IsOK(res1)) {
9271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9272 }
9273 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9274 {
9275 PyThreadState* __tstate = wxPyBeginAllowThreads();
9276 (arg1)->Resume();
9277 wxPyEndAllowThreads(__tstate);
9278 if (PyErr_Occurred()) SWIG_fail;
9279 }
9280 resultobj = SWIG_Py_Void();
9281 return resultobj;
9282 fail:
9283 return NULL;
9284 }
9285
9286
9287 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9288 PyObject *resultobj = 0;
9289 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9290 long result;
9291 void *argp1 = 0 ;
9292 int res1 = 0 ;
9293 PyObject *swig_obj[1] ;
9294
9295 if (!args) SWIG_fail;
9296 swig_obj[0] = args;
9297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9298 if (!SWIG_IsOK(res1)) {
9299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9300 }
9301 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9302 {
9303 PyThreadState* __tstate = wxPyBeginAllowThreads();
9304 result = (long)((wxStopWatch const *)arg1)->Time();
9305 wxPyEndAllowThreads(__tstate);
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 resultobj = SWIG_From_long(static_cast< long >(result));
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9316 PyObject *obj;
9317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9318 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9319 return SWIG_Py_Void();
9320 }
9321
9322 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9323 return SWIG_Python_InitShadowInstance(args);
9324 }
9325
9326 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9327 PyObject *resultobj = 0;
9328 int arg1 = (int) 9 ;
9329 int arg2 = (int) wxID_FILE1 ;
9330 wxFileHistory *result = 0 ;
9331 int val1 ;
9332 int ecode1 = 0 ;
9333 int val2 ;
9334 int ecode2 = 0 ;
9335 PyObject * obj0 = 0 ;
9336 PyObject * obj1 = 0 ;
9337 char * kwnames[] = {
9338 (char *) "maxFiles",(char *) "idBase", NULL
9339 };
9340
9341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9342 if (obj0) {
9343 ecode1 = SWIG_AsVal_int(obj0, &val1);
9344 if (!SWIG_IsOK(ecode1)) {
9345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9346 }
9347 arg1 = static_cast< int >(val1);
9348 }
9349 if (obj1) {
9350 ecode2 = SWIG_AsVal_int(obj1, &val2);
9351 if (!SWIG_IsOK(ecode2)) {
9352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9353 }
9354 arg2 = static_cast< int >(val2);
9355 }
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9370 PyObject *resultobj = 0;
9371 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9372 void *argp1 = 0 ;
9373 int res1 = 0 ;
9374 PyObject *swig_obj[1] ;
9375
9376 if (!args) SWIG_fail;
9377 swig_obj[0] = args;
9378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9379 if (!SWIG_IsOK(res1)) {
9380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9381 }
9382 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 delete arg1;
9386
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 resultobj = SWIG_Py_Void();
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj = 0;
9399 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9400 wxString *arg2 = 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 bool temp2 = false ;
9404 PyObject * obj0 = 0 ;
9405 PyObject * obj1 = 0 ;
9406 char * kwnames[] = {
9407 (char *) "self",(char *) "file", NULL
9408 };
9409
9410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9412 if (!SWIG_IsOK(res1)) {
9413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9414 }
9415 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9416 {
9417 arg2 = wxString_in_helper(obj1);
9418 if (arg2 == NULL) SWIG_fail;
9419 temp2 = true;
9420 }
9421 {
9422 PyThreadState* __tstate = wxPyBeginAllowThreads();
9423 (arg1)->AddFileToHistory((wxString const &)*arg2);
9424 wxPyEndAllowThreads(__tstate);
9425 if (PyErr_Occurred()) SWIG_fail;
9426 }
9427 resultobj = SWIG_Py_Void();
9428 {
9429 if (temp2)
9430 delete arg2;
9431 }
9432 return resultobj;
9433 fail:
9434 {
9435 if (temp2)
9436 delete arg2;
9437 }
9438 return NULL;
9439 }
9440
9441
9442 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9443 PyObject *resultobj = 0;
9444 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9445 int arg2 ;
9446 void *argp1 = 0 ;
9447 int res1 = 0 ;
9448 int val2 ;
9449 int ecode2 = 0 ;
9450 PyObject * obj0 = 0 ;
9451 PyObject * obj1 = 0 ;
9452 char * kwnames[] = {
9453 (char *) "self",(char *) "i", NULL
9454 };
9455
9456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9460 }
9461 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9462 ecode2 = SWIG_AsVal_int(obj1, &val2);
9463 if (!SWIG_IsOK(ecode2)) {
9464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9465 }
9466 arg2 = static_cast< int >(val2);
9467 {
9468 PyThreadState* __tstate = wxPyBeginAllowThreads();
9469 (arg1)->RemoveFileFromHistory(arg2);
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_Py_Void();
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 PyObject *resultobj = 0;
9482 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9483 int result;
9484 void *argp1 = 0 ;
9485 int res1 = 0 ;
9486 PyObject *swig_obj[1] ;
9487
9488 if (!args) SWIG_fail;
9489 swig_obj[0] = args;
9490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9493 }
9494 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9495 {
9496 PyThreadState* __tstate = wxPyBeginAllowThreads();
9497 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9498 wxPyEndAllowThreads(__tstate);
9499 if (PyErr_Occurred()) SWIG_fail;
9500 }
9501 resultobj = SWIG_From_int(static_cast< int >(result));
9502 return resultobj;
9503 fail:
9504 return NULL;
9505 }
9506
9507
9508 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9509 PyObject *resultobj = 0;
9510 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9511 wxMenu *arg2 = (wxMenu *) 0 ;
9512 void *argp1 = 0 ;
9513 int res1 = 0 ;
9514 void *argp2 = 0 ;
9515 int res2 = 0 ;
9516 PyObject * obj0 = 0 ;
9517 PyObject * obj1 = 0 ;
9518 char * kwnames[] = {
9519 (char *) "self",(char *) "menu", NULL
9520 };
9521
9522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9524 if (!SWIG_IsOK(res1)) {
9525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9526 }
9527 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9528 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9529 if (!SWIG_IsOK(res2)) {
9530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9531 }
9532 arg2 = reinterpret_cast< wxMenu * >(argp2);
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 (arg1)->UseMenu(arg2);
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 resultobj = SWIG_Py_Void();
9540 return resultobj;
9541 fail:
9542 return NULL;
9543 }
9544
9545
9546 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9547 PyObject *resultobj = 0;
9548 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9549 wxMenu *arg2 = (wxMenu *) 0 ;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 void *argp2 = 0 ;
9553 int res2 = 0 ;
9554 PyObject * obj0 = 0 ;
9555 PyObject * obj1 = 0 ;
9556 char * kwnames[] = {
9557 (char *) "self",(char *) "menu", NULL
9558 };
9559
9560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9562 if (!SWIG_IsOK(res1)) {
9563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9564 }
9565 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9567 if (!SWIG_IsOK(res2)) {
9568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9569 }
9570 arg2 = reinterpret_cast< wxMenu * >(argp2);
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 (arg1)->RemoveMenu(arg2);
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 resultobj = SWIG_Py_Void();
9578 return resultobj;
9579 fail:
9580 return NULL;
9581 }
9582
9583
9584 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9585 PyObject *resultobj = 0;
9586 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9587 wxConfigBase *arg2 = 0 ;
9588 void *argp1 = 0 ;
9589 int res1 = 0 ;
9590 void *argp2 = 0 ;
9591 int res2 = 0 ;
9592 PyObject * obj0 = 0 ;
9593 PyObject * obj1 = 0 ;
9594 char * kwnames[] = {
9595 (char *) "self",(char *) "config", NULL
9596 };
9597
9598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9600 if (!SWIG_IsOK(res1)) {
9601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9602 }
9603 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9605 if (!SWIG_IsOK(res2)) {
9606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9607 }
9608 if (!argp2) {
9609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9610 }
9611 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9612 {
9613 PyThreadState* __tstate = wxPyBeginAllowThreads();
9614 (arg1)->Load(*arg2);
9615 wxPyEndAllowThreads(__tstate);
9616 if (PyErr_Occurred()) SWIG_fail;
9617 }
9618 resultobj = SWIG_Py_Void();
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9626 PyObject *resultobj = 0;
9627 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9628 wxConfigBase *arg2 = 0 ;
9629 void *argp1 = 0 ;
9630 int res1 = 0 ;
9631 void *argp2 = 0 ;
9632 int res2 = 0 ;
9633 PyObject * obj0 = 0 ;
9634 PyObject * obj1 = 0 ;
9635 char * kwnames[] = {
9636 (char *) "self",(char *) "config", NULL
9637 };
9638
9639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9641 if (!SWIG_IsOK(res1)) {
9642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9643 }
9644 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9645 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9646 if (!SWIG_IsOK(res2)) {
9647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9648 }
9649 if (!argp2) {
9650 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9651 }
9652 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 (arg1)->Save(*arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 PyObject *swig_obj[1] ;
9672
9673 if (!args) SWIG_fail;
9674 swig_obj[0] = args;
9675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9678 }
9679 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 (arg1)->AddFilesToMenu();
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 resultobj = SWIG_Py_Void();
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9694 PyObject *resultobj = 0;
9695 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9696 wxMenu *arg2 = (wxMenu *) 0 ;
9697 void *argp1 = 0 ;
9698 int res1 = 0 ;
9699 void *argp2 = 0 ;
9700 int res2 = 0 ;
9701 PyObject * obj0 = 0 ;
9702 PyObject * obj1 = 0 ;
9703 char * kwnames[] = {
9704 (char *) "self",(char *) "menu", NULL
9705 };
9706
9707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9709 if (!SWIG_IsOK(res1)) {
9710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9711 }
9712 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9714 if (!SWIG_IsOK(res2)) {
9715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9716 }
9717 arg2 = reinterpret_cast< wxMenu * >(argp2);
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 (arg1)->AddFilesToMenu(arg2);
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 resultobj = SWIG_Py_Void();
9725 return resultobj;
9726 fail:
9727 return NULL;
9728 }
9729
9730
9731 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9732 PyObject *resultobj = 0;
9733 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9734 int arg2 ;
9735 wxString result;
9736 void *argp1 = 0 ;
9737 int res1 = 0 ;
9738 int val2 ;
9739 int ecode2 = 0 ;
9740 PyObject * obj0 = 0 ;
9741 PyObject * obj1 = 0 ;
9742 char * kwnames[] = {
9743 (char *) "self",(char *) "i", NULL
9744 };
9745
9746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9748 if (!SWIG_IsOK(res1)) {
9749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9750 }
9751 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9752 ecode2 = SWIG_AsVal_int(obj1, &val2);
9753 if (!SWIG_IsOK(ecode2)) {
9754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9755 }
9756 arg2 = static_cast< int >(val2);
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 {
9764 #if wxUSE_UNICODE
9765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9766 #else
9767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9768 #endif
9769 }
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9777 PyObject *resultobj = 0;
9778 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9779 int result;
9780 void *argp1 = 0 ;
9781 int res1 = 0 ;
9782 PyObject *swig_obj[1] ;
9783
9784 if (!args) SWIG_fail;
9785 swig_obj[0] = args;
9786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9789 }
9790 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 result = (int)((wxFileHistory const *)arg1)->GetCount();
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 resultobj = SWIG_From_int(static_cast< int >(result));
9798 return resultobj;
9799 fail:
9800 return NULL;
9801 }
9802
9803
9804 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9805 PyObject *obj;
9806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9807 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9808 return SWIG_Py_Void();
9809 }
9810
9811 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9812 return SWIG_Python_InitShadowInstance(args);
9813 }
9814
9815 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9816 PyObject *resultobj = 0;
9817 wxString *arg1 = 0 ;
9818 wxString const &arg2_defvalue = wxPyEmptyString ;
9819 wxString *arg2 = (wxString *) &arg2_defvalue ;
9820 wxSingleInstanceChecker *result = 0 ;
9821 bool temp1 = false ;
9822 bool temp2 = false ;
9823 PyObject * obj0 = 0 ;
9824 PyObject * obj1 = 0 ;
9825 char * kwnames[] = {
9826 (char *) "name",(char *) "path", NULL
9827 };
9828
9829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9830 {
9831 arg1 = wxString_in_helper(obj0);
9832 if (arg1 == NULL) SWIG_fail;
9833 temp1 = true;
9834 }
9835 if (obj1) {
9836 {
9837 arg2 = wxString_in_helper(obj1);
9838 if (arg2 == NULL) SWIG_fail;
9839 temp2 = true;
9840 }
9841 }
9842 {
9843 PyThreadState* __tstate = wxPyBeginAllowThreads();
9844 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9849 {
9850 if (temp1)
9851 delete arg1;
9852 }
9853 {
9854 if (temp2)
9855 delete arg2;
9856 }
9857 return resultobj;
9858 fail:
9859 {
9860 if (temp1)
9861 delete arg1;
9862 }
9863 {
9864 if (temp2)
9865 delete arg2;
9866 }
9867 return NULL;
9868 }
9869
9870
9871 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9872 PyObject *resultobj = 0;
9873 wxSingleInstanceChecker *result = 0 ;
9874
9875 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9883 return resultobj;
9884 fail:
9885 return NULL;
9886 }
9887
9888
9889 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 PyObject *resultobj = 0;
9891 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9892 void *argp1 = 0 ;
9893 int res1 = 0 ;
9894 PyObject *swig_obj[1] ;
9895
9896 if (!args) SWIG_fail;
9897 swig_obj[0] = args;
9898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9899 if (!SWIG_IsOK(res1)) {
9900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9901 }
9902 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 delete arg1;
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_Py_Void();
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9918 PyObject *resultobj = 0;
9919 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9920 wxString *arg2 = 0 ;
9921 wxString const &arg3_defvalue = wxPyEmptyString ;
9922 wxString *arg3 = (wxString *) &arg3_defvalue ;
9923 bool result;
9924 void *argp1 = 0 ;
9925 int res1 = 0 ;
9926 bool temp2 = false ;
9927 bool temp3 = false ;
9928 PyObject * obj0 = 0 ;
9929 PyObject * obj1 = 0 ;
9930 PyObject * obj2 = 0 ;
9931 char * kwnames[] = {
9932 (char *) "self",(char *) "name",(char *) "path", NULL
9933 };
9934
9935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9937 if (!SWIG_IsOK(res1)) {
9938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9939 }
9940 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9941 {
9942 arg2 = wxString_in_helper(obj1);
9943 if (arg2 == NULL) SWIG_fail;
9944 temp2 = true;
9945 }
9946 if (obj2) {
9947 {
9948 arg3 = wxString_in_helper(obj2);
9949 if (arg3 == NULL) SWIG_fail;
9950 temp3 = true;
9951 }
9952 }
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 {
9960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9961 }
9962 {
9963 if (temp2)
9964 delete arg2;
9965 }
9966 {
9967 if (temp3)
9968 delete arg3;
9969 }
9970 return resultobj;
9971 fail:
9972 {
9973 if (temp2)
9974 delete arg2;
9975 }
9976 {
9977 if (temp3)
9978 delete arg3;
9979 }
9980 return NULL;
9981 }
9982
9983
9984 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9985 PyObject *resultobj = 0;
9986 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9987 bool result;
9988 void *argp1 = 0 ;
9989 int res1 = 0 ;
9990 PyObject *swig_obj[1] ;
9991
9992 if (!args) SWIG_fail;
9993 swig_obj[0] = args;
9994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9995 if (!SWIG_IsOK(res1)) {
9996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9997 }
9998 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10002 wxPyEndAllowThreads(__tstate);
10003 if (PyErr_Occurred()) SWIG_fail;
10004 }
10005 {
10006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10007 }
10008 return resultobj;
10009 fail:
10010 return NULL;
10011 }
10012
10013
10014 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10015 PyObject *obj;
10016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10017 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10018 return SWIG_Py_Void();
10019 }
10020
10021 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10022 return SWIG_Python_InitShadowInstance(args);
10023 }
10024
10025 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10026 PyObject *resultobj = 0;
10027 wxWindow *arg1 = (wxWindow *) 0 ;
10028 wxDC *arg2 = 0 ;
10029 bool result;
10030 void *argp1 = 0 ;
10031 int res1 = 0 ;
10032 void *argp2 = 0 ;
10033 int res2 = 0 ;
10034 PyObject * obj0 = 0 ;
10035 PyObject * obj1 = 0 ;
10036 char * kwnames[] = {
10037 (char *) "window",(char *) "dc", NULL
10038 };
10039
10040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10042 if (!SWIG_IsOK(res1)) {
10043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10044 }
10045 arg1 = reinterpret_cast< wxWindow * >(argp1);
10046 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10047 if (!SWIG_IsOK(res2)) {
10048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10049 }
10050 if (!argp2) {
10051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10052 }
10053 arg2 = reinterpret_cast< wxDC * >(argp2);
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 {
10061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10062 }
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10070 PyObject *resultobj = 0;
10071 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 PyObject *swig_obj[1] ;
10075
10076 if (!args) SWIG_fail;
10077 swig_obj[0] = args;
10078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10079 if (!SWIG_IsOK(res1)) {
10080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10081 }
10082 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 delete arg1;
10086
10087 wxPyEndAllowThreads(__tstate);
10088 if (PyErr_Occurred()) SWIG_fail;
10089 }
10090 resultobj = SWIG_Py_Void();
10091 return resultobj;
10092 fail:
10093 return NULL;
10094 }
10095
10096
10097 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10098 PyObject *resultobj = 0;
10099 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10100 wxString result;
10101 void *argp1 = 0 ;
10102 int res1 = 0 ;
10103 PyObject *swig_obj[1] ;
10104
10105 if (!args) SWIG_fail;
10106 swig_obj[0] = args;
10107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10108 if (!SWIG_IsOK(res1)) {
10109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10110 }
10111 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 result = (arg1)->GetTip();
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 {
10119 #if wxUSE_UNICODE
10120 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10121 #else
10122 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10123 #endif
10124 }
10125 return resultobj;
10126 fail:
10127 return NULL;
10128 }
10129
10130
10131 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10132 PyObject *resultobj = 0;
10133 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10134 size_t result;
10135 void *argp1 = 0 ;
10136 int res1 = 0 ;
10137 PyObject *swig_obj[1] ;
10138
10139 if (!args) SWIG_fail;
10140 swig_obj[0] = args;
10141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10142 if (!SWIG_IsOK(res1)) {
10143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10144 }
10145 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10146 {
10147 PyThreadState* __tstate = wxPyBeginAllowThreads();
10148 result = (size_t)(arg1)->GetCurrentTip();
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10153 return resultobj;
10154 fail:
10155 return NULL;
10156 }
10157
10158
10159 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10160 PyObject *resultobj = 0;
10161 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10162 wxString *arg2 = 0 ;
10163 wxString result;
10164 void *argp1 = 0 ;
10165 int res1 = 0 ;
10166 bool temp2 = false ;
10167 PyObject * obj0 = 0 ;
10168 PyObject * obj1 = 0 ;
10169 char * kwnames[] = {
10170 (char *) "self",(char *) "tip", NULL
10171 };
10172
10173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10175 if (!SWIG_IsOK(res1)) {
10176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10177 }
10178 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10179 {
10180 arg2 = wxString_in_helper(obj1);
10181 if (arg2 == NULL) SWIG_fail;
10182 temp2 = true;
10183 }
10184 {
10185 PyThreadState* __tstate = wxPyBeginAllowThreads();
10186 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10187 wxPyEndAllowThreads(__tstate);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 {
10191 #if wxUSE_UNICODE
10192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10193 #else
10194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10195 #endif
10196 }
10197 {
10198 if (temp2)
10199 delete arg2;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp2)
10205 delete arg2;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10212 PyObject *obj;
10213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10214 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10215 return SWIG_Py_Void();
10216 }
10217
10218 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj = 0;
10220 size_t arg1 ;
10221 wxPyTipProvider *result = 0 ;
10222 size_t val1 ;
10223 int ecode1 = 0 ;
10224 PyObject * obj0 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "currentTip", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10230 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10231 if (!SWIG_IsOK(ecode1)) {
10232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10233 }
10234 arg1 = static_cast< size_t >(val1);
10235 {
10236 PyThreadState* __tstate = wxPyBeginAllowThreads();
10237 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj = 0;
10250 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10251 PyObject *arg2 = (PyObject *) 0 ;
10252 PyObject *arg3 = (PyObject *) 0 ;
10253 void *argp1 = 0 ;
10254 int res1 = 0 ;
10255 PyObject * obj0 = 0 ;
10256 PyObject * obj1 = 0 ;
10257 PyObject * obj2 = 0 ;
10258 char * kwnames[] = {
10259 (char *) "self",(char *) "self",(char *) "_class", NULL
10260 };
10261
10262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10264 if (!SWIG_IsOK(res1)) {
10265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10266 }
10267 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10268 arg2 = obj1;
10269 arg3 = obj2;
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 (arg1)->_setCallbackInfo(arg2,arg3);
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 resultobj = SWIG_Py_Void();
10277 return resultobj;
10278 fail:
10279 return NULL;
10280 }
10281
10282
10283 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10284 PyObject *obj;
10285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10286 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10287 return SWIG_Py_Void();
10288 }
10289
10290 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10291 return SWIG_Python_InitShadowInstance(args);
10292 }
10293
10294 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10295 PyObject *resultobj = 0;
10296 wxWindow *arg1 = (wxWindow *) 0 ;
10297 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10298 bool arg3 = (bool) true ;
10299 bool result;
10300 void *argp1 = 0 ;
10301 int res1 = 0 ;
10302 void *argp2 = 0 ;
10303 int res2 = 0 ;
10304 bool val3 ;
10305 int ecode3 = 0 ;
10306 PyObject * obj0 = 0 ;
10307 PyObject * obj1 = 0 ;
10308 PyObject * obj2 = 0 ;
10309 char * kwnames[] = {
10310 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10311 };
10312
10313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10315 if (!SWIG_IsOK(res1)) {
10316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10317 }
10318 arg1 = reinterpret_cast< wxWindow * >(argp1);
10319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10320 if (!SWIG_IsOK(res2)) {
10321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10322 }
10323 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10324 if (obj2) {
10325 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10326 if (!SWIG_IsOK(ecode3)) {
10327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10328 }
10329 arg3 = static_cast< bool >(val3);
10330 }
10331 {
10332 if (!wxPyCheckForApp()) SWIG_fail;
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 result = (bool)wxShowTip(arg1,arg2,arg3);
10335 wxPyEndAllowThreads(__tstate);
10336 if (PyErr_Occurred()) SWIG_fail;
10337 }
10338 {
10339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10340 }
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj = 0;
10349 wxString *arg1 = 0 ;
10350 size_t arg2 ;
10351 wxTipProvider *result = 0 ;
10352 bool temp1 = false ;
10353 size_t val2 ;
10354 int ecode2 = 0 ;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 char * kwnames[] = {
10358 (char *) "filename",(char *) "currentTip", NULL
10359 };
10360
10361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10362 {
10363 arg1 = wxString_in_helper(obj0);
10364 if (arg1 == NULL) SWIG_fail;
10365 temp1 = true;
10366 }
10367 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10368 if (!SWIG_IsOK(ecode2)) {
10369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10370 }
10371 arg2 = static_cast< size_t >(val2);
10372 {
10373 if (!wxPyCheckForApp()) SWIG_fail;
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10376 wxPyEndAllowThreads(__tstate);
10377 if (PyErr_Occurred()) SWIG_fail;
10378 }
10379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10380 {
10381 if (temp1)
10382 delete arg1;
10383 }
10384 return resultobj;
10385 fail:
10386 {
10387 if (temp1)
10388 delete arg1;
10389 }
10390 return NULL;
10391 }
10392
10393
10394 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj = 0;
10396 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10397 int arg2 = (int) wxID_ANY ;
10398 wxPyTimer *result = 0 ;
10399 void *argp1 = 0 ;
10400 int res1 = 0 ;
10401 int val2 ;
10402 int ecode2 = 0 ;
10403 PyObject * obj0 = 0 ;
10404 PyObject * obj1 = 0 ;
10405 char * kwnames[] = {
10406 (char *) "owner",(char *) "id", NULL
10407 };
10408
10409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10410 if (obj0) {
10411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10412 if (!SWIG_IsOK(res1)) {
10413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10414 }
10415 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10416 }
10417 if (obj1) {
10418 ecode2 = SWIG_AsVal_int(obj1, &val2);
10419 if (!SWIG_IsOK(ecode2)) {
10420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10421 }
10422 arg2 = static_cast< int >(val2);
10423 }
10424 {
10425 if (!wxPyCheckForApp()) SWIG_fail;
10426 PyThreadState* __tstate = wxPyBeginAllowThreads();
10427 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10439 PyObject *resultobj = 0;
10440 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10441 void *argp1 = 0 ;
10442 int res1 = 0 ;
10443 PyObject *swig_obj[1] ;
10444
10445 if (!args) SWIG_fail;
10446 swig_obj[0] = args;
10447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10448 if (!SWIG_IsOK(res1)) {
10449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10450 }
10451 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 delete arg1;
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 resultobj = SWIG_Py_Void();
10460 return resultobj;
10461 fail:
10462 return NULL;
10463 }
10464
10465
10466 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10467 PyObject *resultobj = 0;
10468 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10469 PyObject *arg2 = (PyObject *) 0 ;
10470 PyObject *arg3 = (PyObject *) 0 ;
10471 int arg4 = (int) 1 ;
10472 void *argp1 = 0 ;
10473 int res1 = 0 ;
10474 int val4 ;
10475 int ecode4 = 0 ;
10476 PyObject * obj0 = 0 ;
10477 PyObject * obj1 = 0 ;
10478 PyObject * obj2 = 0 ;
10479 PyObject * obj3 = 0 ;
10480 char * kwnames[] = {
10481 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10482 };
10483
10484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10486 if (!SWIG_IsOK(res1)) {
10487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10488 }
10489 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10490 arg2 = obj1;
10491 arg3 = obj2;
10492 if (obj3) {
10493 ecode4 = SWIG_AsVal_int(obj3, &val4);
10494 if (!SWIG_IsOK(ecode4)) {
10495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10496 }
10497 arg4 = static_cast< int >(val4);
10498 }
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 resultobj = SWIG_Py_Void();
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10513 PyObject *resultobj = 0;
10514 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10515 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10516 int arg3 = (int) wxID_ANY ;
10517 void *argp1 = 0 ;
10518 int res1 = 0 ;
10519 void *argp2 = 0 ;
10520 int res2 = 0 ;
10521 int val3 ;
10522 int ecode3 = 0 ;
10523 PyObject * obj0 = 0 ;
10524 PyObject * obj1 = 0 ;
10525 PyObject * obj2 = 0 ;
10526 char * kwnames[] = {
10527 (char *) "self",(char *) "owner",(char *) "id", NULL
10528 };
10529
10530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10534 }
10535 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10536 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10537 if (!SWIG_IsOK(res2)) {
10538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10539 }
10540 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10541 if (obj2) {
10542 ecode3 = SWIG_AsVal_int(obj2, &val3);
10543 if (!SWIG_IsOK(ecode3)) {
10544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10545 }
10546 arg3 = static_cast< int >(val3);
10547 }
10548 {
10549 PyThreadState* __tstate = wxPyBeginAllowThreads();
10550 (arg1)->SetOwner(arg2,arg3);
10551 wxPyEndAllowThreads(__tstate);
10552 if (PyErr_Occurred()) SWIG_fail;
10553 }
10554 resultobj = SWIG_Py_Void();
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10562 PyObject *resultobj = 0;
10563 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10564 wxEvtHandler *result = 0 ;
10565 void *argp1 = 0 ;
10566 int res1 = 0 ;
10567 PyObject *swig_obj[1] ;
10568
10569 if (!args) SWIG_fail;
10570 swig_obj[0] = args;
10571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10572 if (!SWIG_IsOK(res1)) {
10573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10574 }
10575 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10576 {
10577 PyThreadState* __tstate = wxPyBeginAllowThreads();
10578 result = (wxEvtHandler *)(arg1)->GetOwner();
10579 wxPyEndAllowThreads(__tstate);
10580 if (PyErr_Occurred()) SWIG_fail;
10581 }
10582 {
10583 resultobj = wxPyMake_wxObject(result, 0);
10584 }
10585 return resultobj;
10586 fail:
10587 return NULL;
10588 }
10589
10590
10591 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10592 PyObject *resultobj = 0;
10593 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10594 int arg2 = (int) -1 ;
10595 bool arg3 = (bool) false ;
10596 bool result;
10597 void *argp1 = 0 ;
10598 int res1 = 0 ;
10599 int val2 ;
10600 int ecode2 = 0 ;
10601 bool val3 ;
10602 int ecode3 = 0 ;
10603 PyObject * obj0 = 0 ;
10604 PyObject * obj1 = 0 ;
10605 PyObject * obj2 = 0 ;
10606 char * kwnames[] = {
10607 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10608 };
10609
10610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10612 if (!SWIG_IsOK(res1)) {
10613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10614 }
10615 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10616 if (obj1) {
10617 ecode2 = SWIG_AsVal_int(obj1, &val2);
10618 if (!SWIG_IsOK(ecode2)) {
10619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10620 }
10621 arg2 = static_cast< int >(val2);
10622 }
10623 if (obj2) {
10624 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10625 if (!SWIG_IsOK(ecode3)) {
10626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10627 }
10628 arg3 = static_cast< bool >(val3);
10629 }
10630 {
10631 PyThreadState* __tstate = wxPyBeginAllowThreads();
10632 result = (bool)(arg1)->Start(arg2,arg3);
10633 wxPyEndAllowThreads(__tstate);
10634 if (PyErr_Occurred()) SWIG_fail;
10635 }
10636 {
10637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10638 }
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10646 PyObject *resultobj = 0;
10647 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 PyObject *swig_obj[1] ;
10651
10652 if (!args) SWIG_fail;
10653 swig_obj[0] = args;
10654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10657 }
10658 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10659 {
10660 PyThreadState* __tstate = wxPyBeginAllowThreads();
10661 (arg1)->Stop();
10662 wxPyEndAllowThreads(__tstate);
10663 if (PyErr_Occurred()) SWIG_fail;
10664 }
10665 resultobj = SWIG_Py_Void();
10666 return resultobj;
10667 fail:
10668 return NULL;
10669 }
10670
10671
10672 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10673 PyObject *resultobj = 0;
10674 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10675 void *argp1 = 0 ;
10676 int res1 = 0 ;
10677 PyObject *swig_obj[1] ;
10678
10679 if (!args) SWIG_fail;
10680 swig_obj[0] = args;
10681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10682 if (!SWIG_IsOK(res1)) {
10683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10684 }
10685 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 (arg1)->Notify();
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 resultobj = SWIG_Py_Void();
10693 return resultobj;
10694 fail:
10695 return NULL;
10696 }
10697
10698
10699 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10700 PyObject *resultobj = 0;
10701 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10702 bool result;
10703 void *argp1 = 0 ;
10704 int res1 = 0 ;
10705 PyObject *swig_obj[1] ;
10706
10707 if (!args) SWIG_fail;
10708 swig_obj[0] = args;
10709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10710 if (!SWIG_IsOK(res1)) {
10711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10712 }
10713 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10714 {
10715 PyThreadState* __tstate = wxPyBeginAllowThreads();
10716 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10717 wxPyEndAllowThreads(__tstate);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 {
10721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10722 }
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10730 PyObject *resultobj = 0;
10731 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10732 int result;
10733 void *argp1 = 0 ;
10734 int res1 = 0 ;
10735 PyObject *swig_obj[1] ;
10736
10737 if (!args) SWIG_fail;
10738 swig_obj[0] = args;
10739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10740 if (!SWIG_IsOK(res1)) {
10741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10742 }
10743 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10744 {
10745 PyThreadState* __tstate = wxPyBeginAllowThreads();
10746 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10747 wxPyEndAllowThreads(__tstate);
10748 if (PyErr_Occurred()) SWIG_fail;
10749 }
10750 resultobj = SWIG_From_int(static_cast< int >(result));
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10758 PyObject *resultobj = 0;
10759 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10760 int result;
10761 void *argp1 = 0 ;
10762 int res1 = 0 ;
10763 PyObject *swig_obj[1] ;
10764
10765 if (!args) SWIG_fail;
10766 swig_obj[0] = args;
10767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10768 if (!SWIG_IsOK(res1)) {
10769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10770 }
10771 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10772 {
10773 PyThreadState* __tstate = wxPyBeginAllowThreads();
10774 result = (int)((wxPyTimer const *)arg1)->GetId();
10775 wxPyEndAllowThreads(__tstate);
10776 if (PyErr_Occurred()) SWIG_fail;
10777 }
10778 resultobj = SWIG_From_int(static_cast< int >(result));
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10786 PyObject *resultobj = 0;
10787 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10788 bool result;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 PyObject *swig_obj[1] ;
10792
10793 if (!args) SWIG_fail;
10794 swig_obj[0] = args;
10795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10796 if (!SWIG_IsOK(res1)) {
10797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10798 }
10799 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10808 }
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10816 PyObject *obj;
10817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10818 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10819 return SWIG_Py_Void();
10820 }
10821
10822 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10823 return SWIG_Python_InitShadowInstance(args);
10824 }
10825
10826 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10827 PyObject *resultobj = 0;
10828 int arg1 = (int) 0 ;
10829 int arg2 = (int) 0 ;
10830 wxTimerEvent *result = 0 ;
10831 int val1 ;
10832 int ecode1 = 0 ;
10833 int val2 ;
10834 int ecode2 = 0 ;
10835 PyObject * obj0 = 0 ;
10836 PyObject * obj1 = 0 ;
10837 char * kwnames[] = {
10838 (char *) "timerid",(char *) "interval", NULL
10839 };
10840
10841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10842 if (obj0) {
10843 ecode1 = SWIG_AsVal_int(obj0, &val1);
10844 if (!SWIG_IsOK(ecode1)) {
10845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10846 }
10847 arg1 = static_cast< int >(val1);
10848 }
10849 if (obj1) {
10850 ecode2 = SWIG_AsVal_int(obj1, &val2);
10851 if (!SWIG_IsOK(ecode2)) {
10852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10853 }
10854 arg2 = static_cast< int >(val2);
10855 }
10856 {
10857 PyThreadState* __tstate = wxPyBeginAllowThreads();
10858 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10859 wxPyEndAllowThreads(__tstate);
10860 if (PyErr_Occurred()) SWIG_fail;
10861 }
10862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10863 return resultobj;
10864 fail:
10865 return NULL;
10866 }
10867
10868
10869 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10870 PyObject *resultobj = 0;
10871 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10872 int result;
10873 void *argp1 = 0 ;
10874 int res1 = 0 ;
10875 PyObject *swig_obj[1] ;
10876
10877 if (!args) SWIG_fail;
10878 swig_obj[0] = args;
10879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10880 if (!SWIG_IsOK(res1)) {
10881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10882 }
10883 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10884 {
10885 PyThreadState* __tstate = wxPyBeginAllowThreads();
10886 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10887 wxPyEndAllowThreads(__tstate);
10888 if (PyErr_Occurred()) SWIG_fail;
10889 }
10890 resultobj = SWIG_From_int(static_cast< int >(result));
10891 return resultobj;
10892 fail:
10893 return NULL;
10894 }
10895
10896
10897 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10898 PyObject *obj;
10899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10900 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10901 return SWIG_Py_Void();
10902 }
10903
10904 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10905 return SWIG_Python_InitShadowInstance(args);
10906 }
10907
10908 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10909 PyObject *resultobj = 0;
10910 wxTimer *arg1 = 0 ;
10911 wxTimerRunner *result = 0 ;
10912 void *argp1 = 0 ;
10913 int res1 = 0 ;
10914
10915 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10917 if (!SWIG_IsOK(res1)) {
10918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10919 }
10920 if (!argp1) {
10921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10922 }
10923 arg1 = reinterpret_cast< wxTimer * >(argp1);
10924 {
10925 if (!wxPyCheckForApp()) SWIG_fail;
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10928 wxPyEndAllowThreads(__tstate);
10929 if (PyErr_Occurred()) SWIG_fail;
10930 }
10931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10932 return resultobj;
10933 fail:
10934 return NULL;
10935 }
10936
10937
10938 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10939 PyObject *resultobj = 0;
10940 wxTimer *arg1 = 0 ;
10941 int arg2 ;
10942 bool arg3 = (bool) false ;
10943 wxTimerRunner *result = 0 ;
10944 void *argp1 = 0 ;
10945 int res1 = 0 ;
10946 int val2 ;
10947 int ecode2 = 0 ;
10948 bool val3 ;
10949 int ecode3 = 0 ;
10950
10951 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10953 if (!SWIG_IsOK(res1)) {
10954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10955 }
10956 if (!argp1) {
10957 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10958 }
10959 arg1 = reinterpret_cast< wxTimer * >(argp1);
10960 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10961 if (!SWIG_IsOK(ecode2)) {
10962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10963 }
10964 arg2 = static_cast< int >(val2);
10965 if (swig_obj[2]) {
10966 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10967 if (!SWIG_IsOK(ecode3)) {
10968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10969 }
10970 arg3 = static_cast< bool >(val3);
10971 }
10972 {
10973 if (!wxPyCheckForApp()) SWIG_fail;
10974 PyThreadState* __tstate = wxPyBeginAllowThreads();
10975 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10976 wxPyEndAllowThreads(__tstate);
10977 if (PyErr_Occurred()) SWIG_fail;
10978 }
10979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10980 return resultobj;
10981 fail:
10982 return NULL;
10983 }
10984
10985
10986 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10987 int argc;
10988 PyObject *argv[4];
10989
10990 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10991 --argc;
10992 if (argc == 1) {
10993 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10994 }
10995 if ((argc >= 2) && (argc <= 3)) {
10996 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10997 }
10998
10999 fail:
11000 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11001 return NULL;
11002 }
11003
11004
11005 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11006 PyObject *resultobj = 0;
11007 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11008 void *argp1 = 0 ;
11009 int res1 = 0 ;
11010 PyObject *swig_obj[1] ;
11011
11012 if (!args) SWIG_fail;
11013 swig_obj[0] = args;
11014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11015 if (!SWIG_IsOK(res1)) {
11016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11017 }
11018 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11019 {
11020 PyThreadState* __tstate = wxPyBeginAllowThreads();
11021 delete arg1;
11022
11023 wxPyEndAllowThreads(__tstate);
11024 if (PyErr_Occurred()) SWIG_fail;
11025 }
11026 resultobj = SWIG_Py_Void();
11027 return resultobj;
11028 fail:
11029 return NULL;
11030 }
11031
11032
11033 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11034 PyObject *resultobj = 0;
11035 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11036 int arg2 ;
11037 bool arg3 = (bool) false ;
11038 void *argp1 = 0 ;
11039 int res1 = 0 ;
11040 int val2 ;
11041 int ecode2 = 0 ;
11042 bool val3 ;
11043 int ecode3 = 0 ;
11044 PyObject * obj0 = 0 ;
11045 PyObject * obj1 = 0 ;
11046 PyObject * obj2 = 0 ;
11047 char * kwnames[] = {
11048 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11049 };
11050
11051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11053 if (!SWIG_IsOK(res1)) {
11054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11055 }
11056 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11057 ecode2 = SWIG_AsVal_int(obj1, &val2);
11058 if (!SWIG_IsOK(ecode2)) {
11059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11060 }
11061 arg2 = static_cast< int >(val2);
11062 if (obj2) {
11063 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11064 if (!SWIG_IsOK(ecode3)) {
11065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11066 }
11067 arg3 = static_cast< bool >(val3);
11068 }
11069 {
11070 PyThreadState* __tstate = wxPyBeginAllowThreads();
11071 (arg1)->Start(arg2,arg3);
11072 wxPyEndAllowThreads(__tstate);
11073 if (PyErr_Occurred()) SWIG_fail;
11074 }
11075 resultobj = SWIG_Py_Void();
11076 return resultobj;
11077 fail:
11078 return NULL;
11079 }
11080
11081
11082 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11083 PyObject *obj;
11084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11085 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11086 return SWIG_Py_Void();
11087 }
11088
11089 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11090 return SWIG_Python_InitShadowInstance(args);
11091 }
11092
11093 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11094 PyObject *resultobj = 0;
11095 wxLog *result = 0 ;
11096
11097 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11098 {
11099 PyThreadState* __tstate = wxPyBeginAllowThreads();
11100 result = (wxLog *)new wxLog();
11101 wxPyEndAllowThreads(__tstate);
11102 if (PyErr_Occurred()) SWIG_fail;
11103 }
11104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11105 return resultobj;
11106 fail:
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11112 PyObject *resultobj = 0;
11113 wxLog *arg1 = (wxLog *) 0 ;
11114 void *argp1 = 0 ;
11115 int res1 = 0 ;
11116 PyObject *swig_obj[1] ;
11117
11118 if (!args) SWIG_fail;
11119 swig_obj[0] = args;
11120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11121 if (!SWIG_IsOK(res1)) {
11122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11123 }
11124 arg1 = reinterpret_cast< wxLog * >(argp1);
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 delete arg1;
11128
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 resultobj = SWIG_Py_Void();
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 bool result;
11142
11143 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 result = (bool)wxLog::IsEnabled();
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 {
11151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11152 }
11153 return resultobj;
11154 fail:
11155 return NULL;
11156 }
11157
11158
11159 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11160 PyObject *resultobj = 0;
11161 bool arg1 = (bool) true ;
11162 bool result;
11163 bool val1 ;
11164 int ecode1 = 0 ;
11165 PyObject * obj0 = 0 ;
11166 char * kwnames[] = {
11167 (char *) "doIt", NULL
11168 };
11169
11170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11171 if (obj0) {
11172 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11173 if (!SWIG_IsOK(ecode1)) {
11174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11175 }
11176 arg1 = static_cast< bool >(val1);
11177 }
11178 {
11179 PyThreadState* __tstate = wxPyBeginAllowThreads();
11180 result = (bool)wxLog::EnableLogging(arg1);
11181 wxPyEndAllowThreads(__tstate);
11182 if (PyErr_Occurred()) SWIG_fail;
11183 }
11184 {
11185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11186 }
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11194 PyObject *resultobj = 0;
11195 wxLogLevel arg1 ;
11196 wxChar *arg2 = (wxChar *) 0 ;
11197 time_t arg3 ;
11198 unsigned long val1 ;
11199 int ecode1 = 0 ;
11200 void *argp2 = 0 ;
11201 int res2 = 0 ;
11202 unsigned int val3 ;
11203 int ecode3 = 0 ;
11204 PyObject * obj0 = 0 ;
11205 PyObject * obj1 = 0 ;
11206 PyObject * obj2 = 0 ;
11207 char * kwnames[] = {
11208 (char *) "level",(char *) "szString",(char *) "t", NULL
11209 };
11210
11211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11212 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11213 if (!SWIG_IsOK(ecode1)) {
11214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11215 }
11216 arg1 = static_cast< wxLogLevel >(val1);
11217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11218 if (!SWIG_IsOK(res2)) {
11219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11220 }
11221 arg2 = reinterpret_cast< wxChar * >(argp2);
11222 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11223 if (!SWIG_IsOK(ecode3)) {
11224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11225 }
11226 arg3 = static_cast< time_t >(val3);
11227 {
11228 PyThreadState* __tstate = wxPyBeginAllowThreads();
11229 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 resultobj = SWIG_Py_Void();
11234 return resultobj;
11235 fail:
11236 return NULL;
11237 }
11238
11239
11240 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11241 PyObject *resultobj = 0;
11242 wxLog *arg1 = (wxLog *) 0 ;
11243 void *argp1 = 0 ;
11244 int res1 = 0 ;
11245 PyObject *swig_obj[1] ;
11246
11247 if (!args) SWIG_fail;
11248 swig_obj[0] = args;
11249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11250 if (!SWIG_IsOK(res1)) {
11251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11252 }
11253 arg1 = reinterpret_cast< wxLog * >(argp1);
11254 {
11255 PyThreadState* __tstate = wxPyBeginAllowThreads();
11256 (arg1)->Flush();
11257 wxPyEndAllowThreads(__tstate);
11258 if (PyErr_Occurred()) SWIG_fail;
11259 }
11260 resultobj = SWIG_Py_Void();
11261 return resultobj;
11262 fail:
11263 return NULL;
11264 }
11265
11266
11267 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11268 PyObject *resultobj = 0;
11269
11270 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 wxLog::FlushActive();
11274 wxPyEndAllowThreads(__tstate);
11275 if (PyErr_Occurred()) SWIG_fail;
11276 }
11277 resultobj = SWIG_Py_Void();
11278 return resultobj;
11279 fail:
11280 return NULL;
11281 }
11282
11283
11284 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11285 PyObject *resultobj = 0;
11286 wxLog *result = 0 ;
11287
11288 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11289 {
11290 PyThreadState* __tstate = wxPyBeginAllowThreads();
11291 result = (wxLog *)wxLog::GetActiveTarget();
11292 wxPyEndAllowThreads(__tstate);
11293 if (PyErr_Occurred()) SWIG_fail;
11294 }
11295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11296 return resultobj;
11297 fail:
11298 return NULL;
11299 }
11300
11301
11302 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11303 PyObject *resultobj = 0;
11304 wxLog *arg1 = (wxLog *) 0 ;
11305 wxLog *result = 0 ;
11306 int res1 = 0 ;
11307 PyObject * obj0 = 0 ;
11308 char * kwnames[] = {
11309 (char *) "pLogger", NULL
11310 };
11311
11312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11313 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11314 if (!SWIG_IsOK(res1)) {
11315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11316 }
11317 {
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11320 wxPyEndAllowThreads(__tstate);
11321 if (PyErr_Occurred()) SWIG_fail;
11322 }
11323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11324 return resultobj;
11325 fail:
11326 return NULL;
11327 }
11328
11329
11330 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11331 PyObject *resultobj = 0;
11332
11333 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11334 {
11335 PyThreadState* __tstate = wxPyBeginAllowThreads();
11336 wxLog::Suspend();
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11348 PyObject *resultobj = 0;
11349
11350 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 wxLog::Resume();
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 return resultobj;
11359 fail:
11360 return NULL;
11361 }
11362
11363
11364 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11365 PyObject *resultobj = 0;
11366 bool arg1 = (bool) true ;
11367 bool val1 ;
11368 int ecode1 = 0 ;
11369 PyObject * obj0 = 0 ;
11370 char * kwnames[] = {
11371 (char *) "bVerbose", NULL
11372 };
11373
11374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11375 if (obj0) {
11376 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11377 if (!SWIG_IsOK(ecode1)) {
11378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11379 }
11380 arg1 = static_cast< bool >(val1);
11381 }
11382 {
11383 PyThreadState* __tstate = wxPyBeginAllowThreads();
11384 wxLog::SetVerbose(arg1);
11385 wxPyEndAllowThreads(__tstate);
11386 if (PyErr_Occurred()) SWIG_fail;
11387 }
11388 resultobj = SWIG_Py_Void();
11389 return resultobj;
11390 fail:
11391 return NULL;
11392 }
11393
11394
11395 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11396 PyObject *resultobj = 0;
11397 wxLogLevel arg1 ;
11398 unsigned long val1 ;
11399 int ecode1 = 0 ;
11400 PyObject * obj0 = 0 ;
11401 char * kwnames[] = {
11402 (char *) "logLevel", NULL
11403 };
11404
11405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11406 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11407 if (!SWIG_IsOK(ecode1)) {
11408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11409 }
11410 arg1 = static_cast< wxLogLevel >(val1);
11411 {
11412 PyThreadState* __tstate = wxPyBeginAllowThreads();
11413 wxLog::SetLogLevel(arg1);
11414 wxPyEndAllowThreads(__tstate);
11415 if (PyErr_Occurred()) SWIG_fail;
11416 }
11417 resultobj = SWIG_Py_Void();
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11425 PyObject *resultobj = 0;
11426
11427 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 wxLog::DontCreateOnDemand();
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 resultobj = SWIG_Py_Void();
11435 return resultobj;
11436 fail:
11437 return NULL;
11438 }
11439
11440
11441 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11442 PyObject *resultobj = 0;
11443 bool arg1 = (bool) true ;
11444 bool val1 ;
11445 int ecode1 = 0 ;
11446 PyObject * obj0 = 0 ;
11447 char * kwnames[] = {
11448 (char *) "bRepetCounting", NULL
11449 };
11450
11451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
11452 if (obj0) {
11453 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11454 if (!SWIG_IsOK(ecode1)) {
11455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
11456 }
11457 arg1 = static_cast< bool >(val1);
11458 }
11459 {
11460 PyThreadState* __tstate = wxPyBeginAllowThreads();
11461 wxLog::SetRepetitionCounting(arg1);
11462 wxPyEndAllowThreads(__tstate);
11463 if (PyErr_Occurred()) SWIG_fail;
11464 }
11465 resultobj = SWIG_Py_Void();
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11473 PyObject *resultobj = 0;
11474 bool result;
11475
11476 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
11477 {
11478 PyThreadState* __tstate = wxPyBeginAllowThreads();
11479 result = (bool)wxLog::GetRepetitionCounting();
11480 wxPyEndAllowThreads(__tstate);
11481 if (PyErr_Occurred()) SWIG_fail;
11482 }
11483 {
11484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11485 }
11486 return resultobj;
11487 fail:
11488 return NULL;
11489 }
11490
11491
11492 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11493 PyObject *resultobj = 0;
11494 wxTraceMask arg1 ;
11495 unsigned long val1 ;
11496 int ecode1 = 0 ;
11497 PyObject * obj0 = 0 ;
11498 char * kwnames[] = {
11499 (char *) "ulMask", NULL
11500 };
11501
11502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11503 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11504 if (!SWIG_IsOK(ecode1)) {
11505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11506 }
11507 arg1 = static_cast< wxTraceMask >(val1);
11508 {
11509 PyThreadState* __tstate = wxPyBeginAllowThreads();
11510 wxLog::SetTraceMask(arg1);
11511 wxPyEndAllowThreads(__tstate);
11512 if (PyErr_Occurred()) SWIG_fail;
11513 }
11514 resultobj = SWIG_Py_Void();
11515 return resultobj;
11516 fail:
11517 return NULL;
11518 }
11519
11520
11521 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11522 PyObject *resultobj = 0;
11523 wxString *arg1 = 0 ;
11524 bool temp1 = false ;
11525 PyObject * obj0 = 0 ;
11526 char * kwnames[] = {
11527 (char *) "str", NULL
11528 };
11529
11530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11531 {
11532 arg1 = wxString_in_helper(obj0);
11533 if (arg1 == NULL) SWIG_fail;
11534 temp1 = true;
11535 }
11536 {
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 wxLog::AddTraceMask((wxString const &)*arg1);
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 resultobj = SWIG_Py_Void();
11543 {
11544 if (temp1)
11545 delete arg1;
11546 }
11547 return resultobj;
11548 fail:
11549 {
11550 if (temp1)
11551 delete arg1;
11552 }
11553 return NULL;
11554 }
11555
11556
11557 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11558 PyObject *resultobj = 0;
11559 wxString *arg1 = 0 ;
11560 bool temp1 = false ;
11561 PyObject * obj0 = 0 ;
11562 char * kwnames[] = {
11563 (char *) "str", NULL
11564 };
11565
11566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11567 {
11568 arg1 = wxString_in_helper(obj0);
11569 if (arg1 == NULL) SWIG_fail;
11570 temp1 = true;
11571 }
11572 {
11573 PyThreadState* __tstate = wxPyBeginAllowThreads();
11574 wxLog::RemoveTraceMask((wxString const &)*arg1);
11575 wxPyEndAllowThreads(__tstate);
11576 if (PyErr_Occurred()) SWIG_fail;
11577 }
11578 resultobj = SWIG_Py_Void();
11579 {
11580 if (temp1)
11581 delete arg1;
11582 }
11583 return resultobj;
11584 fail:
11585 {
11586 if (temp1)
11587 delete arg1;
11588 }
11589 return NULL;
11590 }
11591
11592
11593 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11594 PyObject *resultobj = 0;
11595
11596 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11597 {
11598 PyThreadState* __tstate = wxPyBeginAllowThreads();
11599 wxLog::ClearTraceMasks();
11600 wxPyEndAllowThreads(__tstate);
11601 if (PyErr_Occurred()) SWIG_fail;
11602 }
11603 resultobj = SWIG_Py_Void();
11604 return resultobj;
11605 fail:
11606 return NULL;
11607 }
11608
11609
11610 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11611 PyObject *resultobj = 0;
11612 wxArrayString *result = 0 ;
11613
11614 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 {
11618 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11619 result = (wxArrayString *) &_result_ref;
11620 }
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 {
11625 resultobj = wxArrayString2PyList_helper(*result);
11626 }
11627 return resultobj;
11628 fail:
11629 return NULL;
11630 }
11631
11632
11633 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11634 PyObject *resultobj = 0;
11635 wxChar *arg1 = (wxChar *) 0 ;
11636 void *argp1 = 0 ;
11637 int res1 = 0 ;
11638 PyObject * obj0 = 0 ;
11639 char * kwnames[] = {
11640 (char *) "ts", NULL
11641 };
11642
11643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11645 if (!SWIG_IsOK(res1)) {
11646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11647 }
11648 arg1 = reinterpret_cast< wxChar * >(argp1);
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 wxLog::SetTimestamp((wxChar const *)arg1);
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 resultobj = SWIG_Py_Void();
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11663 PyObject *resultobj = 0;
11664 bool result;
11665
11666 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11667 {
11668 PyThreadState* __tstate = wxPyBeginAllowThreads();
11669 result = (bool)wxLog::GetVerbose();
11670 wxPyEndAllowThreads(__tstate);
11671 if (PyErr_Occurred()) SWIG_fail;
11672 }
11673 {
11674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11675 }
11676 return resultobj;
11677 fail:
11678 return NULL;
11679 }
11680
11681
11682 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11683 PyObject *resultobj = 0;
11684 wxTraceMask result;
11685
11686 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11687 {
11688 PyThreadState* __tstate = wxPyBeginAllowThreads();
11689 result = (wxTraceMask)wxLog::GetTraceMask();
11690 wxPyEndAllowThreads(__tstate);
11691 if (PyErr_Occurred()) SWIG_fail;
11692 }
11693 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11694 return resultobj;
11695 fail:
11696 return NULL;
11697 }
11698
11699
11700 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11701 PyObject *resultobj = 0;
11702 wxChar *arg1 = (wxChar *) 0 ;
11703 bool result;
11704 void *argp1 = 0 ;
11705 int res1 = 0 ;
11706 PyObject * obj0 = 0 ;
11707 char * kwnames[] = {
11708 (char *) "mask", NULL
11709 };
11710
11711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11713 if (!SWIG_IsOK(res1)) {
11714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11715 }
11716 arg1 = reinterpret_cast< wxChar * >(argp1);
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11720 wxPyEndAllowThreads(__tstate);
11721 if (PyErr_Occurred()) SWIG_fail;
11722 }
11723 {
11724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11725 }
11726 return resultobj;
11727 fail:
11728 return NULL;
11729 }
11730
11731
11732 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11733 PyObject *resultobj = 0;
11734 wxLogLevel result;
11735
11736 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (wxLogLevel)wxLog::GetLogLevel();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxChar *result = 0 ;
11753
11754 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11755 {
11756 PyThreadState* __tstate = wxPyBeginAllowThreads();
11757 result = (wxChar *)wxLog::GetTimestamp();
11758 wxPyEndAllowThreads(__tstate);
11759 if (PyErr_Occurred()) SWIG_fail;
11760 }
11761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11762 return resultobj;
11763 fail:
11764 return NULL;
11765 }
11766
11767
11768 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11769 PyObject *resultobj = 0;
11770 wxString result;
11771
11772 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = wxLog_TimeStamp();
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 {
11780 #if wxUSE_UNICODE
11781 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11782 #else
11783 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11784 #endif
11785 }
11786 return resultobj;
11787 fail:
11788 return NULL;
11789 }
11790
11791
11792 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11793 PyObject *resultobj = 0;
11794 wxLog *arg1 = (wxLog *) 0 ;
11795 void *argp1 = 0 ;
11796 int res1 = 0 ;
11797 PyObject *swig_obj[1] ;
11798
11799 if (!args) SWIG_fail;
11800 swig_obj[0] = args;
11801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11802 if (!SWIG_IsOK(res1)) {
11803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11804 }
11805 arg1 = reinterpret_cast< wxLog * >(argp1);
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 wxLog_Destroy(arg1);
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 resultobj = SWIG_Py_Void();
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820 PyObject *obj;
11821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11822 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11823 return SWIG_Py_Void();
11824 }
11825
11826 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11827 return SWIG_Python_InitShadowInstance(args);
11828 }
11829
11830 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11831 PyObject *resultobj = 0;
11832 wxLogStderr *result = 0 ;
11833
11834 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 result = (wxLogStderr *)new wxLogStderr();
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11842 return resultobj;
11843 fail:
11844 return NULL;
11845 }
11846
11847
11848 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11849 PyObject *obj;
11850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11851 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11852 return SWIG_Py_Void();
11853 }
11854
11855 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11856 return SWIG_Python_InitShadowInstance(args);
11857 }
11858
11859 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj = 0;
11861 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11862 wxLogTextCtrl *result = 0 ;
11863 void *argp1 = 0 ;
11864 int res1 = 0 ;
11865 PyObject * obj0 = 0 ;
11866 char * kwnames[] = {
11867 (char *) "pTextCtrl", NULL
11868 };
11869
11870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11872 if (!SWIG_IsOK(res1)) {
11873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11874 }
11875 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11876 {
11877 PyThreadState* __tstate = wxPyBeginAllowThreads();
11878 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11879 wxPyEndAllowThreads(__tstate);
11880 if (PyErr_Occurred()) SWIG_fail;
11881 }
11882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11883 return resultobj;
11884 fail:
11885 return NULL;
11886 }
11887
11888
11889 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11890 PyObject *obj;
11891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11892 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11893 return SWIG_Py_Void();
11894 }
11895
11896 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11897 return SWIG_Python_InitShadowInstance(args);
11898 }
11899
11900 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11901 PyObject *resultobj = 0;
11902 wxLogGui *result = 0 ;
11903
11904 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11905 {
11906 PyThreadState* __tstate = wxPyBeginAllowThreads();
11907 result = (wxLogGui *)new wxLogGui();
11908 wxPyEndAllowThreads(__tstate);
11909 if (PyErr_Occurred()) SWIG_fail;
11910 }
11911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11912 return resultobj;
11913 fail:
11914 return NULL;
11915 }
11916
11917
11918 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11919 PyObject *obj;
11920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11921 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11922 return SWIG_Py_Void();
11923 }
11924
11925 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11926 return SWIG_Python_InitShadowInstance(args);
11927 }
11928
11929 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11930 PyObject *resultobj = 0;
11931 wxFrame *arg1 = (wxFrame *) 0 ;
11932 wxString *arg2 = 0 ;
11933 bool arg3 = (bool) true ;
11934 bool arg4 = (bool) true ;
11935 wxLogWindow *result = 0 ;
11936 void *argp1 = 0 ;
11937 int res1 = 0 ;
11938 bool temp2 = false ;
11939 bool val3 ;
11940 int ecode3 = 0 ;
11941 bool val4 ;
11942 int ecode4 = 0 ;
11943 PyObject * obj0 = 0 ;
11944 PyObject * obj1 = 0 ;
11945 PyObject * obj2 = 0 ;
11946 PyObject * obj3 = 0 ;
11947 char * kwnames[] = {
11948 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11949 };
11950
11951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11953 if (!SWIG_IsOK(res1)) {
11954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11955 }
11956 arg1 = reinterpret_cast< wxFrame * >(argp1);
11957 {
11958 arg2 = wxString_in_helper(obj1);
11959 if (arg2 == NULL) SWIG_fail;
11960 temp2 = true;
11961 }
11962 if (obj2) {
11963 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11964 if (!SWIG_IsOK(ecode3)) {
11965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11966 }
11967 arg3 = static_cast< bool >(val3);
11968 }
11969 if (obj3) {
11970 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11971 if (!SWIG_IsOK(ecode4)) {
11972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11973 }
11974 arg4 = static_cast< bool >(val4);
11975 }
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11983 {
11984 if (temp2)
11985 delete arg2;
11986 }
11987 return resultobj;
11988 fail:
11989 {
11990 if (temp2)
11991 delete arg2;
11992 }
11993 return NULL;
11994 }
11995
11996
11997 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11998 PyObject *resultobj = 0;
11999 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12000 bool arg2 = (bool) true ;
12001 void *argp1 = 0 ;
12002 int res1 = 0 ;
12003 bool val2 ;
12004 int ecode2 = 0 ;
12005 PyObject * obj0 = 0 ;
12006 PyObject * obj1 = 0 ;
12007 char * kwnames[] = {
12008 (char *) "self",(char *) "bShow", NULL
12009 };
12010
12011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12013 if (!SWIG_IsOK(res1)) {
12014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12015 }
12016 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12017 if (obj1) {
12018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12019 if (!SWIG_IsOK(ecode2)) {
12020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12021 }
12022 arg2 = static_cast< bool >(val2);
12023 }
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 (arg1)->Show(arg2);
12027 wxPyEndAllowThreads(__tstate);
12028 if (PyErr_Occurred()) SWIG_fail;
12029 }
12030 resultobj = SWIG_Py_Void();
12031 return resultobj;
12032 fail:
12033 return NULL;
12034 }
12035
12036
12037 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12038 PyObject *resultobj = 0;
12039 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12040 wxFrame *result = 0 ;
12041 void *argp1 = 0 ;
12042 int res1 = 0 ;
12043 PyObject *swig_obj[1] ;
12044
12045 if (!args) SWIG_fail;
12046 swig_obj[0] = args;
12047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12048 if (!SWIG_IsOK(res1)) {
12049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12050 }
12051 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12052 {
12053 PyThreadState* __tstate = wxPyBeginAllowThreads();
12054 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12055 wxPyEndAllowThreads(__tstate);
12056 if (PyErr_Occurred()) SWIG_fail;
12057 }
12058 {
12059 resultobj = wxPyMake_wxObject(result, (bool)0);
12060 }
12061 return resultobj;
12062 fail:
12063 return NULL;
12064 }
12065
12066
12067 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12068 PyObject *resultobj = 0;
12069 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12070 wxLog *result = 0 ;
12071 void *argp1 = 0 ;
12072 int res1 = 0 ;
12073 PyObject *swig_obj[1] ;
12074
12075 if (!args) SWIG_fail;
12076 swig_obj[0] = args;
12077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12078 if (!SWIG_IsOK(res1)) {
12079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12080 }
12081 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12082 {
12083 PyThreadState* __tstate = wxPyBeginAllowThreads();
12084 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12085 wxPyEndAllowThreads(__tstate);
12086 if (PyErr_Occurred()) SWIG_fail;
12087 }
12088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12096 PyObject *resultobj = 0;
12097 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12098 bool result;
12099 void *argp1 = 0 ;
12100 int res1 = 0 ;
12101 PyObject *swig_obj[1] ;
12102
12103 if (!args) SWIG_fail;
12104 swig_obj[0] = args;
12105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12106 if (!SWIG_IsOK(res1)) {
12107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12108 }
12109 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
12113 wxPyEndAllowThreads(__tstate);
12114 if (PyErr_Occurred()) SWIG_fail;
12115 }
12116 {
12117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12118 }
12119 return resultobj;
12120 fail:
12121 return NULL;
12122 }
12123
12124
12125 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12126 PyObject *resultobj = 0;
12127 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12128 bool arg2 ;
12129 void *argp1 = 0 ;
12130 int res1 = 0 ;
12131 bool val2 ;
12132 int ecode2 = 0 ;
12133 PyObject * obj0 = 0 ;
12134 PyObject * obj1 = 0 ;
12135 char * kwnames[] = {
12136 (char *) "self",(char *) "bDoPass", NULL
12137 };
12138
12139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12141 if (!SWIG_IsOK(res1)) {
12142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12143 }
12144 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12145 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12146 if (!SWIG_IsOK(ecode2)) {
12147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12148 }
12149 arg2 = static_cast< bool >(val2);
12150 {
12151 PyThreadState* __tstate = wxPyBeginAllowThreads();
12152 (arg1)->PassMessages(arg2);
12153 wxPyEndAllowThreads(__tstate);
12154 if (PyErr_Occurred()) SWIG_fail;
12155 }
12156 resultobj = SWIG_Py_Void();
12157 return resultobj;
12158 fail:
12159 return NULL;
12160 }
12161
12162
12163 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12164 PyObject *obj;
12165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12166 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
12167 return SWIG_Py_Void();
12168 }
12169
12170 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12171 return SWIG_Python_InitShadowInstance(args);
12172 }
12173
12174 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12175 PyObject *resultobj = 0;
12176 wxLog *arg1 = (wxLog *) 0 ;
12177 wxLogChain *result = 0 ;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 PyObject * obj0 = 0 ;
12181 char * kwnames[] = {
12182 (char *) "logger", NULL
12183 };
12184
12185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12187 if (!SWIG_IsOK(res1)) {
12188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12189 }
12190 arg1 = reinterpret_cast< wxLog * >(argp1);
12191 {
12192 PyThreadState* __tstate = wxPyBeginAllowThreads();
12193 result = (wxLogChain *)new wxLogChain(arg1);
12194 wxPyEndAllowThreads(__tstate);
12195 if (PyErr_Occurred()) SWIG_fail;
12196 }
12197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12198 return resultobj;
12199 fail:
12200 return NULL;
12201 }
12202
12203
12204 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12205 PyObject *resultobj = 0;
12206 wxLogChain *arg1 = (wxLogChain *) 0 ;
12207 wxLog *arg2 = (wxLog *) 0 ;
12208 void *argp1 = 0 ;
12209 int res1 = 0 ;
12210 void *argp2 = 0 ;
12211 int res2 = 0 ;
12212 PyObject * obj0 = 0 ;
12213 PyObject * obj1 = 0 ;
12214 char * kwnames[] = {
12215 (char *) "self",(char *) "logger", NULL
12216 };
12217
12218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12220 if (!SWIG_IsOK(res1)) {
12221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12222 }
12223 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12225 if (!SWIG_IsOK(res2)) {
12226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12227 }
12228 arg2 = reinterpret_cast< wxLog * >(argp2);
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 (arg1)->SetLog(arg2);
12232 wxPyEndAllowThreads(__tstate);
12233 if (PyErr_Occurred()) SWIG_fail;
12234 }
12235 resultobj = SWIG_Py_Void();
12236 return resultobj;
12237 fail:
12238 return NULL;
12239 }
12240
12241
12242 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12243 PyObject *resultobj = 0;
12244 wxLogChain *arg1 = (wxLogChain *) 0 ;
12245 bool arg2 ;
12246 void *argp1 = 0 ;
12247 int res1 = 0 ;
12248 bool val2 ;
12249 int ecode2 = 0 ;
12250 PyObject * obj0 = 0 ;
12251 PyObject * obj1 = 0 ;
12252 char * kwnames[] = {
12253 (char *) "self",(char *) "bDoPass", NULL
12254 };
12255
12256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12258 if (!SWIG_IsOK(res1)) {
12259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12260 }
12261 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12262 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12263 if (!SWIG_IsOK(ecode2)) {
12264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12265 }
12266 arg2 = static_cast< bool >(val2);
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 (arg1)->PassMessages(arg2);
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 resultobj = SWIG_Py_Void();
12274 return resultobj;
12275 fail:
12276 return NULL;
12277 }
12278
12279
12280 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12281 PyObject *resultobj = 0;
12282 wxLogChain *arg1 = (wxLogChain *) 0 ;
12283 bool result;
12284 void *argp1 = 0 ;
12285 int res1 = 0 ;
12286 PyObject *swig_obj[1] ;
12287
12288 if (!args) SWIG_fail;
12289 swig_obj[0] = args;
12290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12291 if (!SWIG_IsOK(res1)) {
12292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12293 }
12294 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 result = (bool)(arg1)->IsPassingMessages();
12298 wxPyEndAllowThreads(__tstate);
12299 if (PyErr_Occurred()) SWIG_fail;
12300 }
12301 {
12302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12303 }
12304 return resultobj;
12305 fail:
12306 return NULL;
12307 }
12308
12309
12310 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12311 PyObject *resultobj = 0;
12312 wxLogChain *arg1 = (wxLogChain *) 0 ;
12313 wxLog *result = 0 ;
12314 void *argp1 = 0 ;
12315 int res1 = 0 ;
12316 PyObject *swig_obj[1] ;
12317
12318 if (!args) SWIG_fail;
12319 swig_obj[0] = args;
12320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12321 if (!SWIG_IsOK(res1)) {
12322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12323 }
12324 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12325 {
12326 PyThreadState* __tstate = wxPyBeginAllowThreads();
12327 result = (wxLog *)(arg1)->GetOldLog();
12328 wxPyEndAllowThreads(__tstate);
12329 if (PyErr_Occurred()) SWIG_fail;
12330 }
12331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12332 return resultobj;
12333 fail:
12334 return NULL;
12335 }
12336
12337
12338 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12339 PyObject *obj;
12340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12341 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12342 return SWIG_Py_Void();
12343 }
12344
12345 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12346 return SWIG_Python_InitShadowInstance(args);
12347 }
12348
12349 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12350 PyObject *resultobj = 0;
12351 wxLogBuffer *result = 0 ;
12352
12353 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12354 {
12355 PyThreadState* __tstate = wxPyBeginAllowThreads();
12356 result = (wxLogBuffer *)new wxLogBuffer();
12357 wxPyEndAllowThreads(__tstate);
12358 if (PyErr_Occurred()) SWIG_fail;
12359 }
12360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12368 PyObject *resultobj = 0;
12369 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12370 wxString *result = 0 ;
12371 void *argp1 = 0 ;
12372 int res1 = 0 ;
12373 PyObject *swig_obj[1] ;
12374
12375 if (!args) SWIG_fail;
12376 swig_obj[0] = args;
12377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12378 if (!SWIG_IsOK(res1)) {
12379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12380 }
12381 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 {
12385 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12386 result = (wxString *) &_result_ref;
12387 }
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 {
12392 #if wxUSE_UNICODE
12393 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12394 #else
12395 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12396 #endif
12397 }
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12405 PyObject *obj;
12406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12407 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12408 return SWIG_Py_Void();
12409 }
12410
12411 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12412 return SWIG_Python_InitShadowInstance(args);
12413 }
12414
12415 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12416 PyObject *resultobj = 0;
12417 unsigned long result;
12418
12419 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 result = (unsigned long)wxSysErrorCode();
12423 wxPyEndAllowThreads(__tstate);
12424 if (PyErr_Occurred()) SWIG_fail;
12425 }
12426 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj = 0;
12435 unsigned long arg1 = (unsigned long) 0 ;
12436 wxString result;
12437 unsigned long val1 ;
12438 int ecode1 = 0 ;
12439 PyObject * obj0 = 0 ;
12440 char * kwnames[] = {
12441 (char *) "nErrCode", NULL
12442 };
12443
12444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12445 if (obj0) {
12446 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12447 if (!SWIG_IsOK(ecode1)) {
12448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12449 }
12450 arg1 = static_cast< unsigned long >(val1);
12451 }
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = wxSysErrorMsg(arg1);
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 {
12459 #if wxUSE_UNICODE
12460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12461 #else
12462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12463 #endif
12464 }
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj = 0;
12473 wxString *arg1 = 0 ;
12474 bool temp1 = false ;
12475 PyObject * obj0 = 0 ;
12476 char * kwnames[] = {
12477 (char *) "msg", NULL
12478 };
12479
12480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12481 {
12482 arg1 = wxString_in_helper(obj0);
12483 if (arg1 == NULL) SWIG_fail;
12484 temp1 = true;
12485 }
12486 {
12487 PyThreadState* __tstate = wxPyBeginAllowThreads();
12488 wxPyLogFatalError((wxString const &)*arg1);
12489 wxPyEndAllowThreads(__tstate);
12490 if (PyErr_Occurred()) SWIG_fail;
12491 }
12492 resultobj = SWIG_Py_Void();
12493 {
12494 if (temp1)
12495 delete arg1;
12496 }
12497 return resultobj;
12498 fail:
12499 {
12500 if (temp1)
12501 delete arg1;
12502 }
12503 return NULL;
12504 }
12505
12506
12507 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12508 PyObject *resultobj = 0;
12509 wxString *arg1 = 0 ;
12510 bool temp1 = false ;
12511 PyObject * obj0 = 0 ;
12512 char * kwnames[] = {
12513 (char *) "msg", NULL
12514 };
12515
12516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12517 {
12518 arg1 = wxString_in_helper(obj0);
12519 if (arg1 == NULL) SWIG_fail;
12520 temp1 = true;
12521 }
12522 {
12523 PyThreadState* __tstate = wxPyBeginAllowThreads();
12524 wxPyLogError((wxString const &)*arg1);
12525 wxPyEndAllowThreads(__tstate);
12526 if (PyErr_Occurred()) SWIG_fail;
12527 }
12528 resultobj = SWIG_Py_Void();
12529 {
12530 if (temp1)
12531 delete arg1;
12532 }
12533 return resultobj;
12534 fail:
12535 {
12536 if (temp1)
12537 delete arg1;
12538 }
12539 return NULL;
12540 }
12541
12542
12543 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj = 0;
12545 wxString *arg1 = 0 ;
12546 bool temp1 = false ;
12547 PyObject * obj0 = 0 ;
12548 char * kwnames[] = {
12549 (char *) "msg", NULL
12550 };
12551
12552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12553 {
12554 arg1 = wxString_in_helper(obj0);
12555 if (arg1 == NULL) SWIG_fail;
12556 temp1 = true;
12557 }
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 wxPyLogWarning((wxString const &)*arg1);
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 resultobj = SWIG_Py_Void();
12565 {
12566 if (temp1)
12567 delete arg1;
12568 }
12569 return resultobj;
12570 fail:
12571 {
12572 if (temp1)
12573 delete arg1;
12574 }
12575 return NULL;
12576 }
12577
12578
12579 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj = 0;
12581 wxString *arg1 = 0 ;
12582 bool temp1 = false ;
12583 PyObject * obj0 = 0 ;
12584 char * kwnames[] = {
12585 (char *) "msg", NULL
12586 };
12587
12588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12589 {
12590 arg1 = wxString_in_helper(obj0);
12591 if (arg1 == NULL) SWIG_fail;
12592 temp1 = true;
12593 }
12594 {
12595 PyThreadState* __tstate = wxPyBeginAllowThreads();
12596 wxPyLogMessage((wxString const &)*arg1);
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 resultobj = SWIG_Py_Void();
12601 {
12602 if (temp1)
12603 delete arg1;
12604 }
12605 return resultobj;
12606 fail:
12607 {
12608 if (temp1)
12609 delete arg1;
12610 }
12611 return NULL;
12612 }
12613
12614
12615 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12616 PyObject *resultobj = 0;
12617 wxString *arg1 = 0 ;
12618 bool temp1 = false ;
12619 PyObject * obj0 = 0 ;
12620 char * kwnames[] = {
12621 (char *) "msg", NULL
12622 };
12623
12624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12625 {
12626 arg1 = wxString_in_helper(obj0);
12627 if (arg1 == NULL) SWIG_fail;
12628 temp1 = true;
12629 }
12630 {
12631 PyThreadState* __tstate = wxPyBeginAllowThreads();
12632 wxPyLogInfo((wxString const &)*arg1);
12633 wxPyEndAllowThreads(__tstate);
12634 if (PyErr_Occurred()) SWIG_fail;
12635 }
12636 resultobj = SWIG_Py_Void();
12637 {
12638 if (temp1)
12639 delete arg1;
12640 }
12641 return resultobj;
12642 fail:
12643 {
12644 if (temp1)
12645 delete arg1;
12646 }
12647 return NULL;
12648 }
12649
12650
12651 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12652 PyObject *resultobj = 0;
12653 wxString *arg1 = 0 ;
12654 bool temp1 = false ;
12655 PyObject * obj0 = 0 ;
12656 char * kwnames[] = {
12657 (char *) "msg", NULL
12658 };
12659
12660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12661 {
12662 arg1 = wxString_in_helper(obj0);
12663 if (arg1 == NULL) SWIG_fail;
12664 temp1 = true;
12665 }
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 wxPyLogDebug((wxString const &)*arg1);
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 resultobj = SWIG_Py_Void();
12673 {
12674 if (temp1)
12675 delete arg1;
12676 }
12677 return resultobj;
12678 fail:
12679 {
12680 if (temp1)
12681 delete arg1;
12682 }
12683 return NULL;
12684 }
12685
12686
12687 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12688 PyObject *resultobj = 0;
12689 wxString *arg1 = 0 ;
12690 bool temp1 = false ;
12691 PyObject * obj0 = 0 ;
12692 char * kwnames[] = {
12693 (char *) "msg", NULL
12694 };
12695
12696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12697 {
12698 arg1 = wxString_in_helper(obj0);
12699 if (arg1 == NULL) SWIG_fail;
12700 temp1 = true;
12701 }
12702 {
12703 PyThreadState* __tstate = wxPyBeginAllowThreads();
12704 wxPyLogVerbose((wxString const &)*arg1);
12705 wxPyEndAllowThreads(__tstate);
12706 if (PyErr_Occurred()) SWIG_fail;
12707 }
12708 resultobj = SWIG_Py_Void();
12709 {
12710 if (temp1)
12711 delete arg1;
12712 }
12713 return resultobj;
12714 fail:
12715 {
12716 if (temp1)
12717 delete arg1;
12718 }
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12724 PyObject *resultobj = 0;
12725 wxString *arg1 = 0 ;
12726 bool temp1 = false ;
12727 PyObject * obj0 = 0 ;
12728 char * kwnames[] = {
12729 (char *) "msg", NULL
12730 };
12731
12732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12733 {
12734 arg1 = wxString_in_helper(obj0);
12735 if (arg1 == NULL) SWIG_fail;
12736 temp1 = true;
12737 }
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 wxPyLogStatus((wxString const &)*arg1);
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 resultobj = SWIG_Py_Void();
12745 {
12746 if (temp1)
12747 delete arg1;
12748 }
12749 return resultobj;
12750 fail:
12751 {
12752 if (temp1)
12753 delete arg1;
12754 }
12755 return NULL;
12756 }
12757
12758
12759 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12760 PyObject *resultobj = 0;
12761 wxFrame *arg1 = (wxFrame *) 0 ;
12762 wxString *arg2 = 0 ;
12763 void *argp1 = 0 ;
12764 int res1 = 0 ;
12765 bool temp2 = false ;
12766 PyObject * obj0 = 0 ;
12767 PyObject * obj1 = 0 ;
12768 char * kwnames[] = {
12769 (char *) "pFrame",(char *) "msg", NULL
12770 };
12771
12772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12774 if (!SWIG_IsOK(res1)) {
12775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12776 }
12777 arg1 = reinterpret_cast< wxFrame * >(argp1);
12778 {
12779 arg2 = wxString_in_helper(obj1);
12780 if (arg2 == NULL) SWIG_fail;
12781 temp2 = true;
12782 }
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 resultobj = SWIG_Py_Void();
12790 {
12791 if (temp2)
12792 delete arg2;
12793 }
12794 return resultobj;
12795 fail:
12796 {
12797 if (temp2)
12798 delete arg2;
12799 }
12800 return NULL;
12801 }
12802
12803
12804 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12805 PyObject *resultobj = 0;
12806 wxString *arg1 = 0 ;
12807 bool temp1 = false ;
12808 PyObject * obj0 = 0 ;
12809 char * kwnames[] = {
12810 (char *) "msg", NULL
12811 };
12812
12813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12814 {
12815 arg1 = wxString_in_helper(obj0);
12816 if (arg1 == NULL) SWIG_fail;
12817 temp1 = true;
12818 }
12819 {
12820 PyThreadState* __tstate = wxPyBeginAllowThreads();
12821 wxPyLogSysError((wxString const &)*arg1);
12822 wxPyEndAllowThreads(__tstate);
12823 if (PyErr_Occurred()) SWIG_fail;
12824 }
12825 resultobj = SWIG_Py_Void();
12826 {
12827 if (temp1)
12828 delete arg1;
12829 }
12830 return resultobj;
12831 fail:
12832 {
12833 if (temp1)
12834 delete arg1;
12835 }
12836 return NULL;
12837 }
12838
12839
12840 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12841 PyObject *resultobj = 0;
12842 unsigned long arg1 ;
12843 wxString *arg2 = 0 ;
12844 unsigned long val1 ;
12845 int ecode1 = 0 ;
12846 bool temp2 = false ;
12847 PyObject * obj0 = 0 ;
12848 PyObject * obj1 = 0 ;
12849 char * kwnames[] = {
12850 (char *) "level",(char *) "msg", NULL
12851 };
12852
12853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12854 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12855 if (!SWIG_IsOK(ecode1)) {
12856 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12857 }
12858 arg1 = static_cast< unsigned long >(val1);
12859 {
12860 arg2 = wxString_in_helper(obj1);
12861 if (arg2 == NULL) SWIG_fail;
12862 temp2 = true;
12863 }
12864 {
12865 PyThreadState* __tstate = wxPyBeginAllowThreads();
12866 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12867 wxPyEndAllowThreads(__tstate);
12868 if (PyErr_Occurred()) SWIG_fail;
12869 }
12870 resultobj = SWIG_Py_Void();
12871 {
12872 if (temp2)
12873 delete arg2;
12874 }
12875 return resultobj;
12876 fail:
12877 {
12878 if (temp2)
12879 delete arg2;
12880 }
12881 return NULL;
12882 }
12883
12884
12885 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12886 PyObject *resultobj = 0;
12887 unsigned long arg1 ;
12888 wxString *arg2 = 0 ;
12889 unsigned long val1 ;
12890 int ecode1 = 0 ;
12891 bool temp2 = false ;
12892
12893 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12894 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12895 if (!SWIG_IsOK(ecode1)) {
12896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12897 }
12898 arg1 = static_cast< unsigned long >(val1);
12899 {
12900 arg2 = wxString_in_helper(swig_obj[1]);
12901 if (arg2 == NULL) SWIG_fail;
12902 temp2 = true;
12903 }
12904 {
12905 PyThreadState* __tstate = wxPyBeginAllowThreads();
12906 wxPyLogTrace(arg1,(wxString const &)*arg2);
12907 wxPyEndAllowThreads(__tstate);
12908 if (PyErr_Occurred()) SWIG_fail;
12909 }
12910 resultobj = SWIG_Py_Void();
12911 {
12912 if (temp2)
12913 delete arg2;
12914 }
12915 return resultobj;
12916 fail:
12917 {
12918 if (temp2)
12919 delete arg2;
12920 }
12921 return NULL;
12922 }
12923
12924
12925 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12926 PyObject *resultobj = 0;
12927 wxString *arg1 = 0 ;
12928 wxString *arg2 = 0 ;
12929 bool temp1 = false ;
12930 bool temp2 = false ;
12931
12932 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12933 {
12934 arg1 = wxString_in_helper(swig_obj[0]);
12935 if (arg1 == NULL) SWIG_fail;
12936 temp1 = true;
12937 }
12938 {
12939 arg2 = wxString_in_helper(swig_obj[1]);
12940 if (arg2 == NULL) SWIG_fail;
12941 temp2 = true;
12942 }
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12946 wxPyEndAllowThreads(__tstate);
12947 if (PyErr_Occurred()) SWIG_fail;
12948 }
12949 resultobj = SWIG_Py_Void();
12950 {
12951 if (temp1)
12952 delete arg1;
12953 }
12954 {
12955 if (temp2)
12956 delete arg2;
12957 }
12958 return resultobj;
12959 fail:
12960 {
12961 if (temp1)
12962 delete arg1;
12963 }
12964 {
12965 if (temp2)
12966 delete arg2;
12967 }
12968 return NULL;
12969 }
12970
12971
12972 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12973 int argc;
12974 PyObject *argv[3];
12975
12976 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12977 --argc;
12978 if (argc == 2) {
12979 int _v = 0;
12980 {
12981 {
12982 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12983 }
12984 }
12985 if (!_v) goto check_1;
12986 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12987 }
12988 check_1:
12989
12990 if (argc == 2) {
12991 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12992 }
12993
12994 fail:
12995 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12996 return NULL;
12997 }
12998
12999
13000 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13001 PyObject *resultobj = 0;
13002 wxString *arg1 = 0 ;
13003 wxString *arg2 = 0 ;
13004 bool temp1 = false ;
13005 bool temp2 = false ;
13006 PyObject * obj0 = 0 ;
13007 PyObject * obj1 = 0 ;
13008 char * kwnames[] = {
13009 (char *) "title",(char *) "text", NULL
13010 };
13011
13012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13013 {
13014 arg1 = wxString_in_helper(obj0);
13015 if (arg1 == NULL) SWIG_fail;
13016 temp1 = true;
13017 }
13018 {
13019 arg2 = wxString_in_helper(obj1);
13020 if (arg2 == NULL) SWIG_fail;
13021 temp2 = true;
13022 }
13023 {
13024 PyThreadState* __tstate = wxPyBeginAllowThreads();
13025 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13026 wxPyEndAllowThreads(__tstate);
13027 if (PyErr_Occurred()) SWIG_fail;
13028 }
13029 resultobj = SWIG_Py_Void();
13030 {
13031 if (temp1)
13032 delete arg1;
13033 }
13034 {
13035 if (temp2)
13036 delete arg2;
13037 }
13038 return resultobj;
13039 fail:
13040 {
13041 if (temp1)
13042 delete arg1;
13043 }
13044 {
13045 if (temp2)
13046 delete arg2;
13047 }
13048 return NULL;
13049 }
13050
13051
13052 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13053 PyObject *resultobj = 0;
13054 wxLogNull *result = 0 ;
13055
13056 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13057 {
13058 PyThreadState* __tstate = wxPyBeginAllowThreads();
13059 result = (wxLogNull *)new wxLogNull();
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13071 PyObject *resultobj = 0;
13072 wxLogNull *arg1 = (wxLogNull *) 0 ;
13073 void *argp1 = 0 ;
13074 int res1 = 0 ;
13075 PyObject *swig_obj[1] ;
13076
13077 if (!args) SWIG_fail;
13078 swig_obj[0] = args;
13079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13080 if (!SWIG_IsOK(res1)) {
13081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13082 }
13083 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13084 {
13085 PyThreadState* __tstate = wxPyBeginAllowThreads();
13086 delete arg1;
13087
13088 wxPyEndAllowThreads(__tstate);
13089 if (PyErr_Occurred()) SWIG_fail;
13090 }
13091 resultobj = SWIG_Py_Void();
13092 return resultobj;
13093 fail:
13094 return NULL;
13095 }
13096
13097
13098 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13099 PyObject *obj;
13100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13101 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13102 return SWIG_Py_Void();
13103 }
13104
13105 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13106 return SWIG_Python_InitShadowInstance(args);
13107 }
13108
13109 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13110 PyObject *resultobj = 0;
13111 wxPyLog *result = 0 ;
13112
13113 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (wxPyLog *)new wxPyLog();
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
13121 return resultobj;
13122 fail:
13123 return NULL;
13124 }
13125
13126
13127 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj = 0;
13129 wxPyLog *arg1 = (wxPyLog *) 0 ;
13130 PyObject *arg2 = (PyObject *) 0 ;
13131 PyObject *arg3 = (PyObject *) 0 ;
13132 void *argp1 = 0 ;
13133 int res1 = 0 ;
13134 PyObject * obj0 = 0 ;
13135 PyObject * obj1 = 0 ;
13136 PyObject * obj2 = 0 ;
13137 char * kwnames[] = {
13138 (char *) "self",(char *) "self",(char *) "_class", NULL
13139 };
13140
13141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
13143 if (!SWIG_IsOK(res1)) {
13144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
13145 }
13146 arg1 = reinterpret_cast< wxPyLog * >(argp1);
13147 arg2 = obj1;
13148 arg3 = obj2;
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 (arg1)->_setCallbackInfo(arg2,arg3);
13152 wxPyEndAllowThreads(__tstate);
13153 if (PyErr_Occurred()) SWIG_fail;
13154 }
13155 resultobj = SWIG_Py_Void();
13156 return resultobj;
13157 fail:
13158 return NULL;
13159 }
13160
13161
13162 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13163 PyObject *obj;
13164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13165 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
13166 return SWIG_Py_Void();
13167 }
13168
13169 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13170 return SWIG_Python_InitShadowInstance(args);
13171 }
13172
13173 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13174 PyObject *resultobj = 0;
13175 int arg1 ;
13176 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13177 int arg3 = (int) wxKILL_NOCHILDREN ;
13178 wxKillError result;
13179 int val1 ;
13180 int ecode1 = 0 ;
13181 int val2 ;
13182 int ecode2 = 0 ;
13183 int val3 ;
13184 int ecode3 = 0 ;
13185 PyObject * obj0 = 0 ;
13186 PyObject * obj1 = 0 ;
13187 PyObject * obj2 = 0 ;
13188 char * kwnames[] = {
13189 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13190 };
13191
13192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13193 ecode1 = SWIG_AsVal_int(obj0, &val1);
13194 if (!SWIG_IsOK(ecode1)) {
13195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13196 }
13197 arg1 = static_cast< int >(val1);
13198 if (obj1) {
13199 ecode2 = SWIG_AsVal_int(obj1, &val2);
13200 if (!SWIG_IsOK(ecode2)) {
13201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13202 }
13203 arg2 = static_cast< wxSignal >(val2);
13204 }
13205 if (obj2) {
13206 ecode3 = SWIG_AsVal_int(obj2, &val3);
13207 if (!SWIG_IsOK(ecode3)) {
13208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13209 }
13210 arg3 = static_cast< int >(val3);
13211 }
13212 {
13213 PyThreadState* __tstate = wxPyBeginAllowThreads();
13214 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13215 wxPyEndAllowThreads(__tstate);
13216 if (PyErr_Occurred()) SWIG_fail;
13217 }
13218 resultobj = SWIG_From_int(static_cast< int >(result));
13219 return resultobj;
13220 fail:
13221 return NULL;
13222 }
13223
13224
13225 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13226 PyObject *resultobj = 0;
13227 int arg1 ;
13228 bool result;
13229 int val1 ;
13230 int ecode1 = 0 ;
13231 PyObject * obj0 = 0 ;
13232 char * kwnames[] = {
13233 (char *) "pid", NULL
13234 };
13235
13236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13237 ecode1 = SWIG_AsVal_int(obj0, &val1);
13238 if (!SWIG_IsOK(ecode1)) {
13239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13240 }
13241 arg1 = static_cast< int >(val1);
13242 {
13243 PyThreadState* __tstate = wxPyBeginAllowThreads();
13244 result = (bool)wxPyProcess::Exists(arg1);
13245 wxPyEndAllowThreads(__tstate);
13246 if (PyErr_Occurred()) SWIG_fail;
13247 }
13248 {
13249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13250 }
13251 return resultobj;
13252 fail:
13253 return NULL;
13254 }
13255
13256
13257 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj = 0;
13259 wxString *arg1 = 0 ;
13260 int arg2 = (int) wxEXEC_ASYNC ;
13261 wxPyProcess *result = 0 ;
13262 bool temp1 = false ;
13263 int val2 ;
13264 int ecode2 = 0 ;
13265 PyObject * obj0 = 0 ;
13266 PyObject * obj1 = 0 ;
13267 char * kwnames[] = {
13268 (char *) "cmd",(char *) "flags", NULL
13269 };
13270
13271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13272 {
13273 arg1 = wxString_in_helper(obj0);
13274 if (arg1 == NULL) SWIG_fail;
13275 temp1 = true;
13276 }
13277 if (obj1) {
13278 ecode2 = SWIG_AsVal_int(obj1, &val2);
13279 if (!SWIG_IsOK(ecode2)) {
13280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13281 }
13282 arg2 = static_cast< int >(val2);
13283 }
13284 {
13285 PyThreadState* __tstate = wxPyBeginAllowThreads();
13286 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13291 {
13292 if (temp1)
13293 delete arg1;
13294 }
13295 return resultobj;
13296 fail:
13297 {
13298 if (temp1)
13299 delete arg1;
13300 }
13301 return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13306 PyObject *resultobj = 0;
13307 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13308 int arg2 = (int) -1 ;
13309 wxPyProcess *result = 0 ;
13310 void *argp1 = 0 ;
13311 int res1 = 0 ;
13312 int val2 ;
13313 int ecode2 = 0 ;
13314 PyObject * obj0 = 0 ;
13315 PyObject * obj1 = 0 ;
13316 char * kwnames[] = {
13317 (char *) "parent",(char *) "id", NULL
13318 };
13319
13320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13321 if (obj0) {
13322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13325 }
13326 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13327 }
13328 if (obj1) {
13329 ecode2 = SWIG_AsVal_int(obj1, &val2);
13330 if (!SWIG_IsOK(ecode2)) {
13331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13332 }
13333 arg2 = static_cast< int >(val2);
13334 }
13335 {
13336 PyThreadState* __tstate = wxPyBeginAllowThreads();
13337 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13338 wxPyEndAllowThreads(__tstate);
13339 if (PyErr_Occurred()) SWIG_fail;
13340 }
13341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13342 return resultobj;
13343 fail:
13344 return NULL;
13345 }
13346
13347
13348 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13349 PyObject *resultobj = 0;
13350 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13351 PyObject *arg2 = (PyObject *) 0 ;
13352 PyObject *arg3 = (PyObject *) 0 ;
13353 void *argp1 = 0 ;
13354 int res1 = 0 ;
13355 PyObject * obj0 = 0 ;
13356 PyObject * obj1 = 0 ;
13357 PyObject * obj2 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "self",(char *) "self",(char *) "_class", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13364 if (!SWIG_IsOK(res1)) {
13365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13366 }
13367 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13368 arg2 = obj1;
13369 arg3 = obj2;
13370 {
13371 PyThreadState* __tstate = wxPyBeginAllowThreads();
13372 (arg1)->_setCallbackInfo(arg2,arg3);
13373 wxPyEndAllowThreads(__tstate);
13374 if (PyErr_Occurred()) SWIG_fail;
13375 }
13376 resultobj = SWIG_Py_Void();
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13384 PyObject *resultobj = 0;
13385 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13386 int arg2 ;
13387 int arg3 ;
13388 void *argp1 = 0 ;
13389 int res1 = 0 ;
13390 int val2 ;
13391 int ecode2 = 0 ;
13392 int val3 ;
13393 int ecode3 = 0 ;
13394 PyObject * obj0 = 0 ;
13395 PyObject * obj1 = 0 ;
13396 PyObject * obj2 = 0 ;
13397 char * kwnames[] = {
13398 (char *) "self",(char *) "pid",(char *) "status", NULL
13399 };
13400
13401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13403 if (!SWIG_IsOK(res1)) {
13404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13405 }
13406 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13407 ecode2 = SWIG_AsVal_int(obj1, &val2);
13408 if (!SWIG_IsOK(ecode2)) {
13409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13410 }
13411 arg2 = static_cast< int >(val2);
13412 ecode3 = SWIG_AsVal_int(obj2, &val3);
13413 if (!SWIG_IsOK(ecode3)) {
13414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13415 }
13416 arg3 = static_cast< int >(val3);
13417 {
13418 PyThreadState* __tstate = wxPyBeginAllowThreads();
13419 (arg1)->OnTerminate(arg2,arg3);
13420 wxPyEndAllowThreads(__tstate);
13421 if (PyErr_Occurred()) SWIG_fail;
13422 }
13423 resultobj = SWIG_Py_Void();
13424 return resultobj;
13425 fail:
13426 return NULL;
13427 }
13428
13429
13430 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13431 PyObject *resultobj = 0;
13432 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13433 void *argp1 = 0 ;
13434 int res1 = 0 ;
13435 PyObject *swig_obj[1] ;
13436
13437 if (!args) SWIG_fail;
13438 swig_obj[0] = args;
13439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13440 if (!SWIG_IsOK(res1)) {
13441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13442 }
13443 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13444 {
13445 PyThreadState* __tstate = wxPyBeginAllowThreads();
13446 (arg1)->Redirect();
13447 wxPyEndAllowThreads(__tstate);
13448 if (PyErr_Occurred()) SWIG_fail;
13449 }
13450 resultobj = SWIG_Py_Void();
13451 return resultobj;
13452 fail:
13453 return NULL;
13454 }
13455
13456
13457 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13458 PyObject *resultobj = 0;
13459 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13460 bool result;
13461 void *argp1 = 0 ;
13462 int res1 = 0 ;
13463 PyObject *swig_obj[1] ;
13464
13465 if (!args) SWIG_fail;
13466 swig_obj[0] = args;
13467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13468 if (!SWIG_IsOK(res1)) {
13469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13470 }
13471 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13472 {
13473 PyThreadState* __tstate = wxPyBeginAllowThreads();
13474 result = (bool)(arg1)->IsRedirected();
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 {
13479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13480 }
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13488 PyObject *resultobj = 0;
13489 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13490 void *argp1 = 0 ;
13491 int res1 = 0 ;
13492 PyObject *swig_obj[1] ;
13493
13494 if (!args) SWIG_fail;
13495 swig_obj[0] = args;
13496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13497 if (!SWIG_IsOK(res1)) {
13498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13499 }
13500 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13501 {
13502 PyThreadState* __tstate = wxPyBeginAllowThreads();
13503 (arg1)->Detach();
13504 wxPyEndAllowThreads(__tstate);
13505 if (PyErr_Occurred()) SWIG_fail;
13506 }
13507 resultobj = SWIG_Py_Void();
13508 return resultobj;
13509 fail:
13510 return NULL;
13511 }
13512
13513
13514 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13515 PyObject *resultobj = 0;
13516 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13517 wxInputStream *result = 0 ;
13518 void *argp1 = 0 ;
13519 int res1 = 0 ;
13520 PyObject *swig_obj[1] ;
13521
13522 if (!args) SWIG_fail;
13523 swig_obj[0] = args;
13524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13525 if (!SWIG_IsOK(res1)) {
13526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13527 }
13528 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 result = (wxInputStream *)(arg1)->GetInputStream();
13532 wxPyEndAllowThreads(__tstate);
13533 if (PyErr_Occurred()) SWIG_fail;
13534 }
13535 {
13536 wxPyInputStream * _ptr = NULL;
13537
13538 if (result) {
13539 _ptr = new wxPyInputStream(result);
13540 }
13541 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13542 }
13543 return resultobj;
13544 fail:
13545 return NULL;
13546 }
13547
13548
13549 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13550 PyObject *resultobj = 0;
13551 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13552 wxInputStream *result = 0 ;
13553 void *argp1 = 0 ;
13554 int res1 = 0 ;
13555 PyObject *swig_obj[1] ;
13556
13557 if (!args) SWIG_fail;
13558 swig_obj[0] = args;
13559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13560 if (!SWIG_IsOK(res1)) {
13561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13562 }
13563 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 result = (wxInputStream *)(arg1)->GetErrorStream();
13567 wxPyEndAllowThreads(__tstate);
13568 if (PyErr_Occurred()) SWIG_fail;
13569 }
13570 {
13571 wxPyInputStream * _ptr = NULL;
13572
13573 if (result) {
13574 _ptr = new wxPyInputStream(result);
13575 }
13576 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13577 }
13578 return resultobj;
13579 fail:
13580 return NULL;
13581 }
13582
13583
13584 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13585 PyObject *resultobj = 0;
13586 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13587 wxOutputStream *result = 0 ;
13588 void *argp1 = 0 ;
13589 int res1 = 0 ;
13590 PyObject *swig_obj[1] ;
13591
13592 if (!args) SWIG_fail;
13593 swig_obj[0] = args;
13594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13595 if (!SWIG_IsOK(res1)) {
13596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13597 }
13598 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13599 {
13600 PyThreadState* __tstate = wxPyBeginAllowThreads();
13601 result = (wxOutputStream *)(arg1)->GetOutputStream();
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13606 return resultobj;
13607 fail:
13608 return NULL;
13609 }
13610
13611
13612 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13613 PyObject *resultobj = 0;
13614 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13615 void *argp1 = 0 ;
13616 int res1 = 0 ;
13617 PyObject *swig_obj[1] ;
13618
13619 if (!args) SWIG_fail;
13620 swig_obj[0] = args;
13621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13622 if (!SWIG_IsOK(res1)) {
13623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13624 }
13625 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13626 {
13627 PyThreadState* __tstate = wxPyBeginAllowThreads();
13628 (arg1)->CloseOutput();
13629 wxPyEndAllowThreads(__tstate);
13630 if (PyErr_Occurred()) SWIG_fail;
13631 }
13632 resultobj = SWIG_Py_Void();
13633 return resultobj;
13634 fail:
13635 return NULL;
13636 }
13637
13638
13639 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13640 PyObject *resultobj = 0;
13641 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13642 bool result;
13643 void *argp1 = 0 ;
13644 int res1 = 0 ;
13645 PyObject *swig_obj[1] ;
13646
13647 if (!args) SWIG_fail;
13648 swig_obj[0] = args;
13649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13650 if (!SWIG_IsOK(res1)) {
13651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13652 }
13653 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13654 {
13655 PyThreadState* __tstate = wxPyBeginAllowThreads();
13656 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13657 wxPyEndAllowThreads(__tstate);
13658 if (PyErr_Occurred()) SWIG_fail;
13659 }
13660 {
13661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13662 }
13663 return resultobj;
13664 fail:
13665 return NULL;
13666 }
13667
13668
13669 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13670 PyObject *resultobj = 0;
13671 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13672 bool result;
13673 void *argp1 = 0 ;
13674 int res1 = 0 ;
13675 PyObject *swig_obj[1] ;
13676
13677 if (!args) SWIG_fail;
13678 swig_obj[0] = args;
13679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13680 if (!SWIG_IsOK(res1)) {
13681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13682 }
13683 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 {
13691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13692 }
13693 return resultobj;
13694 fail:
13695 return NULL;
13696 }
13697
13698
13699 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13700 PyObject *resultobj = 0;
13701 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13702 bool result;
13703 void *argp1 = 0 ;
13704 int res1 = 0 ;
13705 PyObject *swig_obj[1] ;
13706
13707 if (!args) SWIG_fail;
13708 swig_obj[0] = args;
13709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13710 if (!SWIG_IsOK(res1)) {
13711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13712 }
13713 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13714 {
13715 PyThreadState* __tstate = wxPyBeginAllowThreads();
13716 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 {
13721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13722 }
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13730 PyObject *obj;
13731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13732 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13733 return SWIG_Py_Void();
13734 }
13735
13736 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13737 return SWIG_Python_InitShadowInstance(args);
13738 }
13739
13740 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13741 PyObject *resultobj = 0;
13742 int arg1 = (int) 0 ;
13743 int arg2 = (int) 0 ;
13744 int arg3 = (int) 0 ;
13745 wxProcessEvent *result = 0 ;
13746 int val1 ;
13747 int ecode1 = 0 ;
13748 int val2 ;
13749 int ecode2 = 0 ;
13750 int val3 ;
13751 int ecode3 = 0 ;
13752 PyObject * obj0 = 0 ;
13753 PyObject * obj1 = 0 ;
13754 PyObject * obj2 = 0 ;
13755 char * kwnames[] = {
13756 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13757 };
13758
13759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13760 if (obj0) {
13761 ecode1 = SWIG_AsVal_int(obj0, &val1);
13762 if (!SWIG_IsOK(ecode1)) {
13763 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13764 }
13765 arg1 = static_cast< int >(val1);
13766 }
13767 if (obj1) {
13768 ecode2 = SWIG_AsVal_int(obj1, &val2);
13769 if (!SWIG_IsOK(ecode2)) {
13770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13771 }
13772 arg2 = static_cast< int >(val2);
13773 }
13774 if (obj2) {
13775 ecode3 = SWIG_AsVal_int(obj2, &val3);
13776 if (!SWIG_IsOK(ecode3)) {
13777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13778 }
13779 arg3 = static_cast< int >(val3);
13780 }
13781 {
13782 PyThreadState* __tstate = wxPyBeginAllowThreads();
13783 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13784 wxPyEndAllowThreads(__tstate);
13785 if (PyErr_Occurred()) SWIG_fail;
13786 }
13787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13788 return resultobj;
13789 fail:
13790 return NULL;
13791 }
13792
13793
13794 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13795 PyObject *resultobj = 0;
13796 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13797 int result;
13798 void *argp1 = 0 ;
13799 int res1 = 0 ;
13800 PyObject *swig_obj[1] ;
13801
13802 if (!args) SWIG_fail;
13803 swig_obj[0] = args;
13804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13805 if (!SWIG_IsOK(res1)) {
13806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13807 }
13808 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13809 {
13810 PyThreadState* __tstate = wxPyBeginAllowThreads();
13811 result = (int)(arg1)->GetPid();
13812 wxPyEndAllowThreads(__tstate);
13813 if (PyErr_Occurred()) SWIG_fail;
13814 }
13815 resultobj = SWIG_From_int(static_cast< int >(result));
13816 return resultobj;
13817 fail:
13818 return NULL;
13819 }
13820
13821
13822 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13823 PyObject *resultobj = 0;
13824 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13825 int result;
13826 void *argp1 = 0 ;
13827 int res1 = 0 ;
13828 PyObject *swig_obj[1] ;
13829
13830 if (!args) SWIG_fail;
13831 swig_obj[0] = args;
13832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13833 if (!SWIG_IsOK(res1)) {
13834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13835 }
13836 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13837 {
13838 PyThreadState* __tstate = wxPyBeginAllowThreads();
13839 result = (int)(arg1)->GetExitCode();
13840 wxPyEndAllowThreads(__tstate);
13841 if (PyErr_Occurred()) SWIG_fail;
13842 }
13843 resultobj = SWIG_From_int(static_cast< int >(result));
13844 return resultobj;
13845 fail:
13846 return NULL;
13847 }
13848
13849
13850 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13851 PyObject *resultobj = 0;
13852 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13853 int arg2 ;
13854 void *argp1 = 0 ;
13855 int res1 = 0 ;
13856 int val2 ;
13857 int ecode2 = 0 ;
13858 PyObject *swig_obj[2] ;
13859
13860 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13862 if (!SWIG_IsOK(res1)) {
13863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13864 }
13865 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13866 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13867 if (!SWIG_IsOK(ecode2)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13869 }
13870 arg2 = static_cast< int >(val2);
13871 if (arg1) (arg1)->m_pid = arg2;
13872
13873 resultobj = SWIG_Py_Void();
13874 return resultobj;
13875 fail:
13876 return NULL;
13877 }
13878
13879
13880 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13881 PyObject *resultobj = 0;
13882 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13883 int result;
13884 void *argp1 = 0 ;
13885 int res1 = 0 ;
13886 PyObject *swig_obj[1] ;
13887
13888 if (!args) SWIG_fail;
13889 swig_obj[0] = args;
13890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13891 if (!SWIG_IsOK(res1)) {
13892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13893 }
13894 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13895 result = (int) ((arg1)->m_pid);
13896 resultobj = SWIG_From_int(static_cast< int >(result));
13897 return resultobj;
13898 fail:
13899 return NULL;
13900 }
13901
13902
13903 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13904 PyObject *resultobj = 0;
13905 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13906 int arg2 ;
13907 void *argp1 = 0 ;
13908 int res1 = 0 ;
13909 int val2 ;
13910 int ecode2 = 0 ;
13911 PyObject *swig_obj[2] ;
13912
13913 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13915 if (!SWIG_IsOK(res1)) {
13916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13917 }
13918 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13919 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13920 if (!SWIG_IsOK(ecode2)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13922 }
13923 arg2 = static_cast< int >(val2);
13924 if (arg1) (arg1)->m_exitcode = arg2;
13925
13926 resultobj = SWIG_Py_Void();
13927 return resultobj;
13928 fail:
13929 return NULL;
13930 }
13931
13932
13933 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13934 PyObject *resultobj = 0;
13935 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13936 int result;
13937 void *argp1 = 0 ;
13938 int res1 = 0 ;
13939 PyObject *swig_obj[1] ;
13940
13941 if (!args) SWIG_fail;
13942 swig_obj[0] = args;
13943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13944 if (!SWIG_IsOK(res1)) {
13945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13946 }
13947 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13948 result = (int) ((arg1)->m_exitcode);
13949 resultobj = SWIG_From_int(static_cast< int >(result));
13950 return resultobj;
13951 fail:
13952 return NULL;
13953 }
13954
13955
13956 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13957 PyObject *obj;
13958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13959 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13960 return SWIG_Py_Void();
13961 }
13962
13963 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13964 return SWIG_Python_InitShadowInstance(args);
13965 }
13966
13967 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13968 PyObject *resultobj = 0;
13969 wxString *arg1 = 0 ;
13970 int arg2 = (int) wxEXEC_ASYNC ;
13971 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13972 long result;
13973 bool temp1 = false ;
13974 int val2 ;
13975 int ecode2 = 0 ;
13976 void *argp3 = 0 ;
13977 int res3 = 0 ;
13978 PyObject * obj0 = 0 ;
13979 PyObject * obj1 = 0 ;
13980 PyObject * obj2 = 0 ;
13981 char * kwnames[] = {
13982 (char *) "command",(char *) "flags",(char *) "process", NULL
13983 };
13984
13985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13986 {
13987 arg1 = wxString_in_helper(obj0);
13988 if (arg1 == NULL) SWIG_fail;
13989 temp1 = true;
13990 }
13991 if (obj1) {
13992 ecode2 = SWIG_AsVal_int(obj1, &val2);
13993 if (!SWIG_IsOK(ecode2)) {
13994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13995 }
13996 arg2 = static_cast< int >(val2);
13997 }
13998 if (obj2) {
13999 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14000 if (!SWIG_IsOK(res3)) {
14001 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14002 }
14003 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14004 }
14005 {
14006 if (!wxPyCheckForApp()) SWIG_fail;
14007 PyThreadState* __tstate = wxPyBeginAllowThreads();
14008 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14009 wxPyEndAllowThreads(__tstate);
14010 if (PyErr_Occurred()) SWIG_fail;
14011 }
14012 resultobj = SWIG_From_long(static_cast< long >(result));
14013 {
14014 if (temp1)
14015 delete arg1;
14016 }
14017 return resultobj;
14018 fail:
14019 {
14020 if (temp1)
14021 delete arg1;
14022 }
14023 return NULL;
14024 }
14025
14026
14027 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14028 PyObject *resultobj = 0;
14029 long arg1 ;
14030 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14031 wxKillError *arg3 = (wxKillError *) 0 ;
14032 int arg4 = (int) wxKILL_NOCHILDREN ;
14033 int result;
14034 long val1 ;
14035 int ecode1 = 0 ;
14036 int val2 ;
14037 int ecode2 = 0 ;
14038 wxKillError temp3 ;
14039 int val4 ;
14040 int ecode4 = 0 ;
14041 PyObject * obj0 = 0 ;
14042 PyObject * obj1 = 0 ;
14043 PyObject * obj2 = 0 ;
14044 char * kwnames[] = {
14045 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14046 };
14047
14048 {
14049 arg3 = &temp3;
14050 }
14051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14052 ecode1 = SWIG_AsVal_long(obj0, &val1);
14053 if (!SWIG_IsOK(ecode1)) {
14054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14055 }
14056 arg1 = static_cast< long >(val1);
14057 if (obj1) {
14058 ecode2 = SWIG_AsVal_int(obj1, &val2);
14059 if (!SWIG_IsOK(ecode2)) {
14060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14061 }
14062 arg2 = static_cast< wxSignal >(val2);
14063 }
14064 if (obj2) {
14065 ecode4 = SWIG_AsVal_int(obj2, &val4);
14066 if (!SWIG_IsOK(ecode4)) {
14067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14068 }
14069 arg4 = static_cast< int >(val4);
14070 }
14071 {
14072 PyThreadState* __tstate = wxPyBeginAllowThreads();
14073 result = (int)wxKill(arg1,arg2,arg3,arg4);
14074 wxPyEndAllowThreads(__tstate);
14075 if (PyErr_Occurred()) SWIG_fail;
14076 }
14077 resultobj = SWIG_From_int(static_cast< int >(result));
14078 {
14079 PyObject* o;
14080 o = PyInt_FromLong((long) (*arg3));
14081
14082
14083
14084 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14085
14086 }
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14094 PyObject *resultobj = 0;
14095 int arg1 = (int) wxJOYSTICK1 ;
14096 wxJoystick *result = 0 ;
14097 int val1 ;
14098 int ecode1 = 0 ;
14099 PyObject * obj0 = 0 ;
14100 char * kwnames[] = {
14101 (char *) "joystick", NULL
14102 };
14103
14104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14105 if (obj0) {
14106 ecode1 = SWIG_AsVal_int(obj0, &val1);
14107 if (!SWIG_IsOK(ecode1)) {
14108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
14109 }
14110 arg1 = static_cast< int >(val1);
14111 }
14112 {
14113 if (!wxPyCheckForApp()) SWIG_fail;
14114 PyThreadState* __tstate = wxPyBeginAllowThreads();
14115 result = (wxJoystick *)new wxJoystick(arg1);
14116 wxPyEndAllowThreads(__tstate);
14117 if (PyErr_Occurred()) SWIG_fail;
14118 }
14119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
14120 return resultobj;
14121 fail:
14122 return NULL;
14123 }
14124
14125
14126 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14127 PyObject *resultobj = 0;
14128 wxJoystick *arg1 = (wxJoystick *) 0 ;
14129 void *argp1 = 0 ;
14130 int res1 = 0 ;
14131 PyObject *swig_obj[1] ;
14132
14133 if (!args) SWIG_fail;
14134 swig_obj[0] = args;
14135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
14136 if (!SWIG_IsOK(res1)) {
14137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
14138 }
14139 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14140 {
14141 PyThreadState* __tstate = wxPyBeginAllowThreads();
14142 delete arg1;
14143
14144 wxPyEndAllowThreads(__tstate);
14145 if (PyErr_Occurred()) SWIG_fail;
14146 }
14147 resultobj = SWIG_Py_Void();
14148 return resultobj;
14149 fail:
14150 return NULL;
14151 }
14152
14153
14154 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14155 PyObject *resultobj = 0;
14156 wxJoystick *arg1 = (wxJoystick *) 0 ;
14157 wxPoint result;
14158 void *argp1 = 0 ;
14159 int res1 = 0 ;
14160 PyObject *swig_obj[1] ;
14161
14162 if (!args) SWIG_fail;
14163 swig_obj[0] = args;
14164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14167 }
14168 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14169 {
14170 PyThreadState* __tstate = wxPyBeginAllowThreads();
14171 result = (arg1)->GetPosition();
14172 wxPyEndAllowThreads(__tstate);
14173 if (PyErr_Occurred()) SWIG_fail;
14174 }
14175 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14176 return resultobj;
14177 fail:
14178 return NULL;
14179 }
14180
14181
14182 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14183 PyObject *resultobj = 0;
14184 wxJoystick *arg1 = (wxJoystick *) 0 ;
14185 int result;
14186 void *argp1 = 0 ;
14187 int res1 = 0 ;
14188 PyObject *swig_obj[1] ;
14189
14190 if (!args) SWIG_fail;
14191 swig_obj[0] = args;
14192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14193 if (!SWIG_IsOK(res1)) {
14194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14195 }
14196 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 result = (int)(arg1)->GetZPosition();
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 resultobj = SWIG_From_int(static_cast< int >(result));
14204 return resultobj;
14205 fail:
14206 return NULL;
14207 }
14208
14209
14210 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14211 PyObject *resultobj = 0;
14212 wxJoystick *arg1 = (wxJoystick *) 0 ;
14213 int result;
14214 void *argp1 = 0 ;
14215 int res1 = 0 ;
14216 PyObject *swig_obj[1] ;
14217
14218 if (!args) SWIG_fail;
14219 swig_obj[0] = args;
14220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14221 if (!SWIG_IsOK(res1)) {
14222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14223 }
14224 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14225 {
14226 PyThreadState* __tstate = wxPyBeginAllowThreads();
14227 result = (int)(arg1)->GetButtonState();
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 resultobj = SWIG_From_int(static_cast< int >(result));
14232 return resultobj;
14233 fail:
14234 return NULL;
14235 }
14236
14237
14238 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14239 PyObject *resultobj = 0;
14240 wxJoystick *arg1 = (wxJoystick *) 0 ;
14241 int result;
14242 void *argp1 = 0 ;
14243 int res1 = 0 ;
14244 PyObject *swig_obj[1] ;
14245
14246 if (!args) SWIG_fail;
14247 swig_obj[0] = args;
14248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14249 if (!SWIG_IsOK(res1)) {
14250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14251 }
14252 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14253 {
14254 PyThreadState* __tstate = wxPyBeginAllowThreads();
14255 result = (int)(arg1)->GetPOVPosition();
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 resultobj = SWIG_From_int(static_cast< int >(result));
14260 return resultobj;
14261 fail:
14262 return NULL;
14263 }
14264
14265
14266 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14267 PyObject *resultobj = 0;
14268 wxJoystick *arg1 = (wxJoystick *) 0 ;
14269 int result;
14270 void *argp1 = 0 ;
14271 int res1 = 0 ;
14272 PyObject *swig_obj[1] ;
14273
14274 if (!args) SWIG_fail;
14275 swig_obj[0] = args;
14276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14277 if (!SWIG_IsOK(res1)) {
14278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14279 }
14280 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 result = (int)(arg1)->GetPOVCTSPosition();
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 resultobj = SWIG_From_int(static_cast< int >(result));
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14295 PyObject *resultobj = 0;
14296 wxJoystick *arg1 = (wxJoystick *) 0 ;
14297 int result;
14298 void *argp1 = 0 ;
14299 int res1 = 0 ;
14300 PyObject *swig_obj[1] ;
14301
14302 if (!args) SWIG_fail;
14303 swig_obj[0] = args;
14304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14305 if (!SWIG_IsOK(res1)) {
14306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14307 }
14308 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14309 {
14310 PyThreadState* __tstate = wxPyBeginAllowThreads();
14311 result = (int)(arg1)->GetRudderPosition();
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 resultobj = SWIG_From_int(static_cast< int >(result));
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14323 PyObject *resultobj = 0;
14324 wxJoystick *arg1 = (wxJoystick *) 0 ;
14325 int result;
14326 void *argp1 = 0 ;
14327 int res1 = 0 ;
14328 PyObject *swig_obj[1] ;
14329
14330 if (!args) SWIG_fail;
14331 swig_obj[0] = args;
14332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14333 if (!SWIG_IsOK(res1)) {
14334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14335 }
14336 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14337 {
14338 PyThreadState* __tstate = wxPyBeginAllowThreads();
14339 result = (int)(arg1)->GetUPosition();
14340 wxPyEndAllowThreads(__tstate);
14341 if (PyErr_Occurred()) SWIG_fail;
14342 }
14343 resultobj = SWIG_From_int(static_cast< int >(result));
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14351 PyObject *resultobj = 0;
14352 wxJoystick *arg1 = (wxJoystick *) 0 ;
14353 int result;
14354 void *argp1 = 0 ;
14355 int res1 = 0 ;
14356 PyObject *swig_obj[1] ;
14357
14358 if (!args) SWIG_fail;
14359 swig_obj[0] = args;
14360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14361 if (!SWIG_IsOK(res1)) {
14362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14363 }
14364 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (int)(arg1)->GetVPosition();
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 resultobj = SWIG_From_int(static_cast< int >(result));
14372 return resultobj;
14373 fail:
14374 return NULL;
14375 }
14376
14377
14378 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14379 PyObject *resultobj = 0;
14380 wxJoystick *arg1 = (wxJoystick *) 0 ;
14381 int result;
14382 void *argp1 = 0 ;
14383 int res1 = 0 ;
14384 PyObject *swig_obj[1] ;
14385
14386 if (!args) SWIG_fail;
14387 swig_obj[0] = args;
14388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14389 if (!SWIG_IsOK(res1)) {
14390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14391 }
14392 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 result = (int)(arg1)->GetMovementThreshold();
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 resultobj = SWIG_From_int(static_cast< int >(result));
14400 return resultobj;
14401 fail:
14402 return NULL;
14403 }
14404
14405
14406 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj = 0;
14408 wxJoystick *arg1 = (wxJoystick *) 0 ;
14409 int arg2 ;
14410 void *argp1 = 0 ;
14411 int res1 = 0 ;
14412 int val2 ;
14413 int ecode2 = 0 ;
14414 PyObject * obj0 = 0 ;
14415 PyObject * obj1 = 0 ;
14416 char * kwnames[] = {
14417 (char *) "self",(char *) "threshold", NULL
14418 };
14419
14420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14422 if (!SWIG_IsOK(res1)) {
14423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14424 }
14425 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14426 ecode2 = SWIG_AsVal_int(obj1, &val2);
14427 if (!SWIG_IsOK(ecode2)) {
14428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14429 }
14430 arg2 = static_cast< int >(val2);
14431 {
14432 PyThreadState* __tstate = wxPyBeginAllowThreads();
14433 (arg1)->SetMovementThreshold(arg2);
14434 wxPyEndAllowThreads(__tstate);
14435 if (PyErr_Occurred()) SWIG_fail;
14436 }
14437 resultobj = SWIG_Py_Void();
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14445 PyObject *resultobj = 0;
14446 wxJoystick *arg1 = (wxJoystick *) 0 ;
14447 bool result;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 PyObject *swig_obj[1] ;
14451
14452 if (!args) SWIG_fail;
14453 swig_obj[0] = args;
14454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14455 if (!SWIG_IsOK(res1)) {
14456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14457 }
14458 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 result = (bool)(arg1)->IsOk();
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 {
14466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14467 }
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14475 PyObject *resultobj = 0;
14476 wxJoystick *arg1 = (wxJoystick *) 0 ;
14477 int result;
14478 void *argp1 = 0 ;
14479 int res1 = 0 ;
14480 PyObject *swig_obj[1] ;
14481
14482 if (!args) SWIG_fail;
14483 swig_obj[0] = args;
14484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14485 if (!SWIG_IsOK(res1)) {
14486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14487 }
14488 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14489 {
14490 PyThreadState* __tstate = wxPyBeginAllowThreads();
14491 result = (int)(arg1)->GetNumberJoysticks();
14492 wxPyEndAllowThreads(__tstate);
14493 if (PyErr_Occurred()) SWIG_fail;
14494 }
14495 resultobj = SWIG_From_int(static_cast< int >(result));
14496 return resultobj;
14497 fail:
14498 return NULL;
14499 }
14500
14501
14502 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14503 PyObject *resultobj = 0;
14504 wxJoystick *arg1 = (wxJoystick *) 0 ;
14505 int result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 PyObject *swig_obj[1] ;
14509
14510 if (!args) SWIG_fail;
14511 swig_obj[0] = args;
14512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14513 if (!SWIG_IsOK(res1)) {
14514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14515 }
14516 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (int)(arg1)->GetManufacturerId();
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 resultobj = SWIG_From_int(static_cast< int >(result));
14524 return resultobj;
14525 fail:
14526 return NULL;
14527 }
14528
14529
14530 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14531 PyObject *resultobj = 0;
14532 wxJoystick *arg1 = (wxJoystick *) 0 ;
14533 int result;
14534 void *argp1 = 0 ;
14535 int res1 = 0 ;
14536 PyObject *swig_obj[1] ;
14537
14538 if (!args) SWIG_fail;
14539 swig_obj[0] = args;
14540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14541 if (!SWIG_IsOK(res1)) {
14542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14543 }
14544 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 result = (int)(arg1)->GetProductId();
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 resultobj = SWIG_From_int(static_cast< int >(result));
14552 return resultobj;
14553 fail:
14554 return NULL;
14555 }
14556
14557
14558 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14559 PyObject *resultobj = 0;
14560 wxJoystick *arg1 = (wxJoystick *) 0 ;
14561 wxString result;
14562 void *argp1 = 0 ;
14563 int res1 = 0 ;
14564 PyObject *swig_obj[1] ;
14565
14566 if (!args) SWIG_fail;
14567 swig_obj[0] = args;
14568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14569 if (!SWIG_IsOK(res1)) {
14570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14571 }
14572 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14573 {
14574 PyThreadState* __tstate = wxPyBeginAllowThreads();
14575 result = (arg1)->GetProductName();
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 {
14580 #if wxUSE_UNICODE
14581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14582 #else
14583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14584 #endif
14585 }
14586 return resultobj;
14587 fail:
14588 return NULL;
14589 }
14590
14591
14592 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14593 PyObject *resultobj = 0;
14594 wxJoystick *arg1 = (wxJoystick *) 0 ;
14595 int result;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 PyObject *swig_obj[1] ;
14599
14600 if (!args) SWIG_fail;
14601 swig_obj[0] = args;
14602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14603 if (!SWIG_IsOK(res1)) {
14604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14605 }
14606 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14607 {
14608 PyThreadState* __tstate = wxPyBeginAllowThreads();
14609 result = (int)(arg1)->GetXMin();
14610 wxPyEndAllowThreads(__tstate);
14611 if (PyErr_Occurred()) SWIG_fail;
14612 }
14613 resultobj = SWIG_From_int(static_cast< int >(result));
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14621 PyObject *resultobj = 0;
14622 wxJoystick *arg1 = (wxJoystick *) 0 ;
14623 int result;
14624 void *argp1 = 0 ;
14625 int res1 = 0 ;
14626 PyObject *swig_obj[1] ;
14627
14628 if (!args) SWIG_fail;
14629 swig_obj[0] = args;
14630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14631 if (!SWIG_IsOK(res1)) {
14632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14633 }
14634 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14635 {
14636 PyThreadState* __tstate = wxPyBeginAllowThreads();
14637 result = (int)(arg1)->GetYMin();
14638 wxPyEndAllowThreads(__tstate);
14639 if (PyErr_Occurred()) SWIG_fail;
14640 }
14641 resultobj = SWIG_From_int(static_cast< int >(result));
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14649 PyObject *resultobj = 0;
14650 wxJoystick *arg1 = (wxJoystick *) 0 ;
14651 int result;
14652 void *argp1 = 0 ;
14653 int res1 = 0 ;
14654 PyObject *swig_obj[1] ;
14655
14656 if (!args) SWIG_fail;
14657 swig_obj[0] = args;
14658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14659 if (!SWIG_IsOK(res1)) {
14660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14661 }
14662 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (int)(arg1)->GetZMin();
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 resultobj = SWIG_From_int(static_cast< int >(result));
14670 return resultobj;
14671 fail:
14672 return NULL;
14673 }
14674
14675
14676 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14677 PyObject *resultobj = 0;
14678 wxJoystick *arg1 = (wxJoystick *) 0 ;
14679 int result;
14680 void *argp1 = 0 ;
14681 int res1 = 0 ;
14682 PyObject *swig_obj[1] ;
14683
14684 if (!args) SWIG_fail;
14685 swig_obj[0] = args;
14686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14687 if (!SWIG_IsOK(res1)) {
14688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14689 }
14690 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 result = (int)(arg1)->GetXMax();
14694 wxPyEndAllowThreads(__tstate);
14695 if (PyErr_Occurred()) SWIG_fail;
14696 }
14697 resultobj = SWIG_From_int(static_cast< int >(result));
14698 return resultobj;
14699 fail:
14700 return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14705 PyObject *resultobj = 0;
14706 wxJoystick *arg1 = (wxJoystick *) 0 ;
14707 int result;
14708 void *argp1 = 0 ;
14709 int res1 = 0 ;
14710 PyObject *swig_obj[1] ;
14711
14712 if (!args) SWIG_fail;
14713 swig_obj[0] = args;
14714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14715 if (!SWIG_IsOK(res1)) {
14716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14717 }
14718 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (int)(arg1)->GetYMax();
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 resultobj = SWIG_From_int(static_cast< int >(result));
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxJoystick *arg1 = (wxJoystick *) 0 ;
14735 int result;
14736 void *argp1 = 0 ;
14737 int res1 = 0 ;
14738 PyObject *swig_obj[1] ;
14739
14740 if (!args) SWIG_fail;
14741 swig_obj[0] = args;
14742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14745 }
14746 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 result = (int)(arg1)->GetZMax();
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 resultobj = SWIG_From_int(static_cast< int >(result));
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14761 PyObject *resultobj = 0;
14762 wxJoystick *arg1 = (wxJoystick *) 0 ;
14763 int result;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 PyObject *swig_obj[1] ;
14767
14768 if (!args) SWIG_fail;
14769 swig_obj[0] = args;
14770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14771 if (!SWIG_IsOK(res1)) {
14772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14773 }
14774 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (int)(arg1)->GetNumberButtons();
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 resultobj = SWIG_From_int(static_cast< int >(result));
14782 return resultobj;
14783 fail:
14784 return NULL;
14785 }
14786
14787
14788 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14789 PyObject *resultobj = 0;
14790 wxJoystick *arg1 = (wxJoystick *) 0 ;
14791 int result;
14792 void *argp1 = 0 ;
14793 int res1 = 0 ;
14794 PyObject *swig_obj[1] ;
14795
14796 if (!args) SWIG_fail;
14797 swig_obj[0] = args;
14798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14799 if (!SWIG_IsOK(res1)) {
14800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14801 }
14802 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14803 {
14804 PyThreadState* __tstate = wxPyBeginAllowThreads();
14805 result = (int)(arg1)->GetNumberAxes();
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 resultobj = SWIG_From_int(static_cast< int >(result));
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14817 PyObject *resultobj = 0;
14818 wxJoystick *arg1 = (wxJoystick *) 0 ;
14819 int result;
14820 void *argp1 = 0 ;
14821 int res1 = 0 ;
14822 PyObject *swig_obj[1] ;
14823
14824 if (!args) SWIG_fail;
14825 swig_obj[0] = args;
14826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14829 }
14830 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14831 {
14832 PyThreadState* __tstate = wxPyBeginAllowThreads();
14833 result = (int)(arg1)->GetMaxButtons();
14834 wxPyEndAllowThreads(__tstate);
14835 if (PyErr_Occurred()) SWIG_fail;
14836 }
14837 resultobj = SWIG_From_int(static_cast< int >(result));
14838 return resultobj;
14839 fail:
14840 return NULL;
14841 }
14842
14843
14844 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14845 PyObject *resultobj = 0;
14846 wxJoystick *arg1 = (wxJoystick *) 0 ;
14847 int result;
14848 void *argp1 = 0 ;
14849 int res1 = 0 ;
14850 PyObject *swig_obj[1] ;
14851
14852 if (!args) SWIG_fail;
14853 swig_obj[0] = args;
14854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14855 if (!SWIG_IsOK(res1)) {
14856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14857 }
14858 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (int)(arg1)->GetMaxAxes();
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 resultobj = SWIG_From_int(static_cast< int >(result));
14866 return resultobj;
14867 fail:
14868 return NULL;
14869 }
14870
14871
14872 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14873 PyObject *resultobj = 0;
14874 wxJoystick *arg1 = (wxJoystick *) 0 ;
14875 int result;
14876 void *argp1 = 0 ;
14877 int res1 = 0 ;
14878 PyObject *swig_obj[1] ;
14879
14880 if (!args) SWIG_fail;
14881 swig_obj[0] = args;
14882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14883 if (!SWIG_IsOK(res1)) {
14884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14885 }
14886 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14887 {
14888 PyThreadState* __tstate = wxPyBeginAllowThreads();
14889 result = (int)(arg1)->GetPollingMin();
14890 wxPyEndAllowThreads(__tstate);
14891 if (PyErr_Occurred()) SWIG_fail;
14892 }
14893 resultobj = SWIG_From_int(static_cast< int >(result));
14894 return resultobj;
14895 fail:
14896 return NULL;
14897 }
14898
14899
14900 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14901 PyObject *resultobj = 0;
14902 wxJoystick *arg1 = (wxJoystick *) 0 ;
14903 int result;
14904 void *argp1 = 0 ;
14905 int res1 = 0 ;
14906 PyObject *swig_obj[1] ;
14907
14908 if (!args) SWIG_fail;
14909 swig_obj[0] = args;
14910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14911 if (!SWIG_IsOK(res1)) {
14912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14913 }
14914 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (int)(arg1)->GetPollingMax();
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_From_int(static_cast< int >(result));
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14929 PyObject *resultobj = 0;
14930 wxJoystick *arg1 = (wxJoystick *) 0 ;
14931 int result;
14932 void *argp1 = 0 ;
14933 int res1 = 0 ;
14934 PyObject *swig_obj[1] ;
14935
14936 if (!args) SWIG_fail;
14937 swig_obj[0] = args;
14938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14939 if (!SWIG_IsOK(res1)) {
14940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14941 }
14942 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (int)(arg1)->GetRudderMin();
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 resultobj = SWIG_From_int(static_cast< int >(result));
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14957 PyObject *resultobj = 0;
14958 wxJoystick *arg1 = (wxJoystick *) 0 ;
14959 int result;
14960 void *argp1 = 0 ;
14961 int res1 = 0 ;
14962 PyObject *swig_obj[1] ;
14963
14964 if (!args) SWIG_fail;
14965 swig_obj[0] = args;
14966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14967 if (!SWIG_IsOK(res1)) {
14968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14969 }
14970 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14971 {
14972 PyThreadState* __tstate = wxPyBeginAllowThreads();
14973 result = (int)(arg1)->GetRudderMax();
14974 wxPyEndAllowThreads(__tstate);
14975 if (PyErr_Occurred()) SWIG_fail;
14976 }
14977 resultobj = SWIG_From_int(static_cast< int >(result));
14978 return resultobj;
14979 fail:
14980 return NULL;
14981 }
14982
14983
14984 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14985 PyObject *resultobj = 0;
14986 wxJoystick *arg1 = (wxJoystick *) 0 ;
14987 int result;
14988 void *argp1 = 0 ;
14989 int res1 = 0 ;
14990 PyObject *swig_obj[1] ;
14991
14992 if (!args) SWIG_fail;
14993 swig_obj[0] = args;
14994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14995 if (!SWIG_IsOK(res1)) {
14996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14997 }
14998 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 result = (int)(arg1)->GetUMin();
15002 wxPyEndAllowThreads(__tstate);
15003 if (PyErr_Occurred()) SWIG_fail;
15004 }
15005 resultobj = SWIG_From_int(static_cast< int >(result));
15006 return resultobj;
15007 fail:
15008 return NULL;
15009 }
15010
15011
15012 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15013 PyObject *resultobj = 0;
15014 wxJoystick *arg1 = (wxJoystick *) 0 ;
15015 int result;
15016 void *argp1 = 0 ;
15017 int res1 = 0 ;
15018 PyObject *swig_obj[1] ;
15019
15020 if (!args) SWIG_fail;
15021 swig_obj[0] = args;
15022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15023 if (!SWIG_IsOK(res1)) {
15024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15025 }
15026 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (int)(arg1)->GetUMax();
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 resultobj = SWIG_From_int(static_cast< int >(result));
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15041 PyObject *resultobj = 0;
15042 wxJoystick *arg1 = (wxJoystick *) 0 ;
15043 int result;
15044 void *argp1 = 0 ;
15045 int res1 = 0 ;
15046 PyObject *swig_obj[1] ;
15047
15048 if (!args) SWIG_fail;
15049 swig_obj[0] = args;
15050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15051 if (!SWIG_IsOK(res1)) {
15052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15053 }
15054 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = (int)(arg1)->GetVMin();
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 resultobj = SWIG_From_int(static_cast< int >(result));
15062 return resultobj;
15063 fail:
15064 return NULL;
15065 }
15066
15067
15068 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15069 PyObject *resultobj = 0;
15070 wxJoystick *arg1 = (wxJoystick *) 0 ;
15071 int result;
15072 void *argp1 = 0 ;
15073 int res1 = 0 ;
15074 PyObject *swig_obj[1] ;
15075
15076 if (!args) SWIG_fail;
15077 swig_obj[0] = args;
15078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15079 if (!SWIG_IsOK(res1)) {
15080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15081 }
15082 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15083 {
15084 PyThreadState* __tstate = wxPyBeginAllowThreads();
15085 result = (int)(arg1)->GetVMax();
15086 wxPyEndAllowThreads(__tstate);
15087 if (PyErr_Occurred()) SWIG_fail;
15088 }
15089 resultobj = SWIG_From_int(static_cast< int >(result));
15090 return resultobj;
15091 fail:
15092 return NULL;
15093 }
15094
15095
15096 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15097 PyObject *resultobj = 0;
15098 wxJoystick *arg1 = (wxJoystick *) 0 ;
15099 bool result;
15100 void *argp1 = 0 ;
15101 int res1 = 0 ;
15102 PyObject *swig_obj[1] ;
15103
15104 if (!args) SWIG_fail;
15105 swig_obj[0] = args;
15106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15107 if (!SWIG_IsOK(res1)) {
15108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
15109 }
15110 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15111 {
15112 PyThreadState* __tstate = wxPyBeginAllowThreads();
15113 result = (bool)(arg1)->HasRudder();
15114 wxPyEndAllowThreads(__tstate);
15115 if (PyErr_Occurred()) SWIG_fail;
15116 }
15117 {
15118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15119 }
15120 return resultobj;
15121 fail:
15122 return NULL;
15123 }
15124
15125
15126 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15127 PyObject *resultobj = 0;
15128 wxJoystick *arg1 = (wxJoystick *) 0 ;
15129 bool result;
15130 void *argp1 = 0 ;
15131 int res1 = 0 ;
15132 PyObject *swig_obj[1] ;
15133
15134 if (!args) SWIG_fail;
15135 swig_obj[0] = args;
15136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15137 if (!SWIG_IsOK(res1)) {
15138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
15139 }
15140 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15141 {
15142 PyThreadState* __tstate = wxPyBeginAllowThreads();
15143 result = (bool)(arg1)->HasZ();
15144 wxPyEndAllowThreads(__tstate);
15145 if (PyErr_Occurred()) SWIG_fail;
15146 }
15147 {
15148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15149 }
15150 return resultobj;
15151 fail:
15152 return NULL;
15153 }
15154
15155
15156 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15157 PyObject *resultobj = 0;
15158 wxJoystick *arg1 = (wxJoystick *) 0 ;
15159 bool result;
15160 void *argp1 = 0 ;
15161 int res1 = 0 ;
15162 PyObject *swig_obj[1] ;
15163
15164 if (!args) SWIG_fail;
15165 swig_obj[0] = args;
15166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15167 if (!SWIG_IsOK(res1)) {
15168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
15169 }
15170 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 result = (bool)(arg1)->HasU();
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 {
15178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15179 }
15180 return resultobj;
15181 fail:
15182 return NULL;
15183 }
15184
15185
15186 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15187 PyObject *resultobj = 0;
15188 wxJoystick *arg1 = (wxJoystick *) 0 ;
15189 bool result;
15190 void *argp1 = 0 ;
15191 int res1 = 0 ;
15192 PyObject *swig_obj[1] ;
15193
15194 if (!args) SWIG_fail;
15195 swig_obj[0] = args;
15196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15197 if (!SWIG_IsOK(res1)) {
15198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15199 }
15200 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15201 {
15202 PyThreadState* __tstate = wxPyBeginAllowThreads();
15203 result = (bool)(arg1)->HasV();
15204 wxPyEndAllowThreads(__tstate);
15205 if (PyErr_Occurred()) SWIG_fail;
15206 }
15207 {
15208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15209 }
15210 return resultobj;
15211 fail:
15212 return NULL;
15213 }
15214
15215
15216 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15217 PyObject *resultobj = 0;
15218 wxJoystick *arg1 = (wxJoystick *) 0 ;
15219 bool result;
15220 void *argp1 = 0 ;
15221 int res1 = 0 ;
15222 PyObject *swig_obj[1] ;
15223
15224 if (!args) SWIG_fail;
15225 swig_obj[0] = args;
15226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15227 if (!SWIG_IsOK(res1)) {
15228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15229 }
15230 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 result = (bool)(arg1)->HasPOV();
15234 wxPyEndAllowThreads(__tstate);
15235 if (PyErr_Occurred()) SWIG_fail;
15236 }
15237 {
15238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15239 }
15240 return resultobj;
15241 fail:
15242 return NULL;
15243 }
15244
15245
15246 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15247 PyObject *resultobj = 0;
15248 wxJoystick *arg1 = (wxJoystick *) 0 ;
15249 bool result;
15250 void *argp1 = 0 ;
15251 int res1 = 0 ;
15252 PyObject *swig_obj[1] ;
15253
15254 if (!args) SWIG_fail;
15255 swig_obj[0] = args;
15256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15257 if (!SWIG_IsOK(res1)) {
15258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15259 }
15260 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15261 {
15262 PyThreadState* __tstate = wxPyBeginAllowThreads();
15263 result = (bool)(arg1)->HasPOV4Dir();
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 {
15268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15269 }
15270 return resultobj;
15271 fail:
15272 return NULL;
15273 }
15274
15275
15276 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15277 PyObject *resultobj = 0;
15278 wxJoystick *arg1 = (wxJoystick *) 0 ;
15279 bool result;
15280 void *argp1 = 0 ;
15281 int res1 = 0 ;
15282 PyObject *swig_obj[1] ;
15283
15284 if (!args) SWIG_fail;
15285 swig_obj[0] = args;
15286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15287 if (!SWIG_IsOK(res1)) {
15288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15289 }
15290 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15291 {
15292 PyThreadState* __tstate = wxPyBeginAllowThreads();
15293 result = (bool)(arg1)->HasPOVCTS();
15294 wxPyEndAllowThreads(__tstate);
15295 if (PyErr_Occurred()) SWIG_fail;
15296 }
15297 {
15298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15299 }
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15307 PyObject *resultobj = 0;
15308 wxJoystick *arg1 = (wxJoystick *) 0 ;
15309 wxWindow *arg2 = (wxWindow *) 0 ;
15310 int arg3 = (int) 0 ;
15311 bool result;
15312 void *argp1 = 0 ;
15313 int res1 = 0 ;
15314 void *argp2 = 0 ;
15315 int res2 = 0 ;
15316 int val3 ;
15317 int ecode3 = 0 ;
15318 PyObject * obj0 = 0 ;
15319 PyObject * obj1 = 0 ;
15320 PyObject * obj2 = 0 ;
15321 char * kwnames[] = {
15322 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15323 };
15324
15325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15329 }
15330 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15331 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15332 if (!SWIG_IsOK(res2)) {
15333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15334 }
15335 arg2 = reinterpret_cast< wxWindow * >(argp2);
15336 if (obj2) {
15337 ecode3 = SWIG_AsVal_int(obj2, &val3);
15338 if (!SWIG_IsOK(ecode3)) {
15339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15340 }
15341 arg3 = static_cast< int >(val3);
15342 }
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (bool)(arg1)->SetCapture(arg2,arg3);
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 {
15350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15351 }
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15359 PyObject *resultobj = 0;
15360 wxJoystick *arg1 = (wxJoystick *) 0 ;
15361 bool result;
15362 void *argp1 = 0 ;
15363 int res1 = 0 ;
15364 PyObject *swig_obj[1] ;
15365
15366 if (!args) SWIG_fail;
15367 swig_obj[0] = args;
15368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15369 if (!SWIG_IsOK(res1)) {
15370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15371 }
15372 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15373 {
15374 PyThreadState* __tstate = wxPyBeginAllowThreads();
15375 result = (bool)(arg1)->ReleaseCapture();
15376 wxPyEndAllowThreads(__tstate);
15377 if (PyErr_Occurred()) SWIG_fail;
15378 }
15379 {
15380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15381 }
15382 return resultobj;
15383 fail:
15384 return NULL;
15385 }
15386
15387
15388 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15389 PyObject *obj;
15390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15391 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15392 return SWIG_Py_Void();
15393 }
15394
15395 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15396 return SWIG_Python_InitShadowInstance(args);
15397 }
15398
15399 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15400 PyObject *resultobj = 0;
15401 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15402 int arg2 = (int) 0 ;
15403 int arg3 = (int) wxJOYSTICK1 ;
15404 int arg4 = (int) 0 ;
15405 wxJoystickEvent *result = 0 ;
15406 int val1 ;
15407 int ecode1 = 0 ;
15408 int val2 ;
15409 int ecode2 = 0 ;
15410 int val3 ;
15411 int ecode3 = 0 ;
15412 int val4 ;
15413 int ecode4 = 0 ;
15414 PyObject * obj0 = 0 ;
15415 PyObject * obj1 = 0 ;
15416 PyObject * obj2 = 0 ;
15417 PyObject * obj3 = 0 ;
15418 char * kwnames[] = {
15419 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15420 };
15421
15422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15423 if (obj0) {
15424 ecode1 = SWIG_AsVal_int(obj0, &val1);
15425 if (!SWIG_IsOK(ecode1)) {
15426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15427 }
15428 arg1 = static_cast< wxEventType >(val1);
15429 }
15430 if (obj1) {
15431 ecode2 = SWIG_AsVal_int(obj1, &val2);
15432 if (!SWIG_IsOK(ecode2)) {
15433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15434 }
15435 arg2 = static_cast< int >(val2);
15436 }
15437 if (obj2) {
15438 ecode3 = SWIG_AsVal_int(obj2, &val3);
15439 if (!SWIG_IsOK(ecode3)) {
15440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15441 }
15442 arg3 = static_cast< int >(val3);
15443 }
15444 if (obj3) {
15445 ecode4 = SWIG_AsVal_int(obj3, &val4);
15446 if (!SWIG_IsOK(ecode4)) {
15447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15448 }
15449 arg4 = static_cast< int >(val4);
15450 }
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15454 wxPyEndAllowThreads(__tstate);
15455 if (PyErr_Occurred()) SWIG_fail;
15456 }
15457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15458 return resultobj;
15459 fail:
15460 return NULL;
15461 }
15462
15463
15464 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15465 PyObject *resultobj = 0;
15466 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15467 wxPoint result;
15468 void *argp1 = 0 ;
15469 int res1 = 0 ;
15470 PyObject *swig_obj[1] ;
15471
15472 if (!args) SWIG_fail;
15473 swig_obj[0] = args;
15474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15475 if (!SWIG_IsOK(res1)) {
15476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15477 }
15478 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15479 {
15480 PyThreadState* __tstate = wxPyBeginAllowThreads();
15481 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15482 wxPyEndAllowThreads(__tstate);
15483 if (PyErr_Occurred()) SWIG_fail;
15484 }
15485 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15486 return resultobj;
15487 fail:
15488 return NULL;
15489 }
15490
15491
15492 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15493 PyObject *resultobj = 0;
15494 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15495 int result;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 PyObject *swig_obj[1] ;
15499
15500 if (!args) SWIG_fail;
15501 swig_obj[0] = args;
15502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15503 if (!SWIG_IsOK(res1)) {
15504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15505 }
15506 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15507 {
15508 PyThreadState* __tstate = wxPyBeginAllowThreads();
15509 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15510 wxPyEndAllowThreads(__tstate);
15511 if (PyErr_Occurred()) SWIG_fail;
15512 }
15513 resultobj = SWIG_From_int(static_cast< int >(result));
15514 return resultobj;
15515 fail:
15516 return NULL;
15517 }
15518
15519
15520 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15521 PyObject *resultobj = 0;
15522 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15523 int result;
15524 void *argp1 = 0 ;
15525 int res1 = 0 ;
15526 PyObject *swig_obj[1] ;
15527
15528 if (!args) SWIG_fail;
15529 swig_obj[0] = args;
15530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15531 if (!SWIG_IsOK(res1)) {
15532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15533 }
15534 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15535 {
15536 PyThreadState* __tstate = wxPyBeginAllowThreads();
15537 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15538 wxPyEndAllowThreads(__tstate);
15539 if (PyErr_Occurred()) SWIG_fail;
15540 }
15541 resultobj = SWIG_From_int(static_cast< int >(result));
15542 return resultobj;
15543 fail:
15544 return NULL;
15545 }
15546
15547
15548 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15549 PyObject *resultobj = 0;
15550 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15551 int result;
15552 void *argp1 = 0 ;
15553 int res1 = 0 ;
15554 PyObject *swig_obj[1] ;
15555
15556 if (!args) SWIG_fail;
15557 swig_obj[0] = args;
15558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15559 if (!SWIG_IsOK(res1)) {
15560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15561 }
15562 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15563 {
15564 PyThreadState* __tstate = wxPyBeginAllowThreads();
15565 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15566 wxPyEndAllowThreads(__tstate);
15567 if (PyErr_Occurred()) SWIG_fail;
15568 }
15569 resultobj = SWIG_From_int(static_cast< int >(result));
15570 return resultobj;
15571 fail:
15572 return NULL;
15573 }
15574
15575
15576 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15577 PyObject *resultobj = 0;
15578 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15579 int result;
15580 void *argp1 = 0 ;
15581 int res1 = 0 ;
15582 PyObject *swig_obj[1] ;
15583
15584 if (!args) SWIG_fail;
15585 swig_obj[0] = args;
15586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15587 if (!SWIG_IsOK(res1)) {
15588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15589 }
15590 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15591 {
15592 PyThreadState* __tstate = wxPyBeginAllowThreads();
15593 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 resultobj = SWIG_From_int(static_cast< int >(result));
15598 return resultobj;
15599 fail:
15600 return NULL;
15601 }
15602
15603
15604 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15605 PyObject *resultobj = 0;
15606 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15607 int arg2 ;
15608 void *argp1 = 0 ;
15609 int res1 = 0 ;
15610 int val2 ;
15611 int ecode2 = 0 ;
15612 PyObject * obj0 = 0 ;
15613 PyObject * obj1 = 0 ;
15614 char * kwnames[] = {
15615 (char *) "self",(char *) "stick", NULL
15616 };
15617
15618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15620 if (!SWIG_IsOK(res1)) {
15621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15622 }
15623 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15624 ecode2 = SWIG_AsVal_int(obj1, &val2);
15625 if (!SWIG_IsOK(ecode2)) {
15626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15627 }
15628 arg2 = static_cast< int >(val2);
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 (arg1)->SetJoystick(arg2);
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 resultobj = SWIG_Py_Void();
15636 return resultobj;
15637 fail:
15638 return NULL;
15639 }
15640
15641
15642 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15643 PyObject *resultobj = 0;
15644 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15645 int arg2 ;
15646 void *argp1 = 0 ;
15647 int res1 = 0 ;
15648 int val2 ;
15649 int ecode2 = 0 ;
15650 PyObject * obj0 = 0 ;
15651 PyObject * obj1 = 0 ;
15652 char * kwnames[] = {
15653 (char *) "self",(char *) "state", NULL
15654 };
15655
15656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15658 if (!SWIG_IsOK(res1)) {
15659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15660 }
15661 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15662 ecode2 = SWIG_AsVal_int(obj1, &val2);
15663 if (!SWIG_IsOK(ecode2)) {
15664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15665 }
15666 arg2 = static_cast< int >(val2);
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 (arg1)->SetButtonState(arg2);
15670 wxPyEndAllowThreads(__tstate);
15671 if (PyErr_Occurred()) SWIG_fail;
15672 }
15673 resultobj = SWIG_Py_Void();
15674 return resultobj;
15675 fail:
15676 return NULL;
15677 }
15678
15679
15680 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15681 PyObject *resultobj = 0;
15682 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15683 int arg2 ;
15684 void *argp1 = 0 ;
15685 int res1 = 0 ;
15686 int val2 ;
15687 int ecode2 = 0 ;
15688 PyObject * obj0 = 0 ;
15689 PyObject * obj1 = 0 ;
15690 char * kwnames[] = {
15691 (char *) "self",(char *) "change", NULL
15692 };
15693
15694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15696 if (!SWIG_IsOK(res1)) {
15697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15698 }
15699 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15700 ecode2 = SWIG_AsVal_int(obj1, &val2);
15701 if (!SWIG_IsOK(ecode2)) {
15702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15703 }
15704 arg2 = static_cast< int >(val2);
15705 {
15706 PyThreadState* __tstate = wxPyBeginAllowThreads();
15707 (arg1)->SetButtonChange(arg2);
15708 wxPyEndAllowThreads(__tstate);
15709 if (PyErr_Occurred()) SWIG_fail;
15710 }
15711 resultobj = SWIG_Py_Void();
15712 return resultobj;
15713 fail:
15714 return NULL;
15715 }
15716
15717
15718 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15719 PyObject *resultobj = 0;
15720 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15721 wxPoint *arg2 = 0 ;
15722 void *argp1 = 0 ;
15723 int res1 = 0 ;
15724 wxPoint temp2 ;
15725 PyObject * obj0 = 0 ;
15726 PyObject * obj1 = 0 ;
15727 char * kwnames[] = {
15728 (char *) "self",(char *) "pos", NULL
15729 };
15730
15731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15733 if (!SWIG_IsOK(res1)) {
15734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15735 }
15736 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15737 {
15738 arg2 = &temp2;
15739 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15740 }
15741 {
15742 PyThreadState* __tstate = wxPyBeginAllowThreads();
15743 (arg1)->SetPosition((wxPoint const &)*arg2);
15744 wxPyEndAllowThreads(__tstate);
15745 if (PyErr_Occurred()) SWIG_fail;
15746 }
15747 resultobj = SWIG_Py_Void();
15748 return resultobj;
15749 fail:
15750 return NULL;
15751 }
15752
15753
15754 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15755 PyObject *resultobj = 0;
15756 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15757 int arg2 ;
15758 void *argp1 = 0 ;
15759 int res1 = 0 ;
15760 int val2 ;
15761 int ecode2 = 0 ;
15762 PyObject * obj0 = 0 ;
15763 PyObject * obj1 = 0 ;
15764 char * kwnames[] = {
15765 (char *) "self",(char *) "zPos", NULL
15766 };
15767
15768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15770 if (!SWIG_IsOK(res1)) {
15771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15772 }
15773 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15774 ecode2 = SWIG_AsVal_int(obj1, &val2);
15775 if (!SWIG_IsOK(ecode2)) {
15776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15777 }
15778 arg2 = static_cast< int >(val2);
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 (arg1)->SetZPosition(arg2);
15782 wxPyEndAllowThreads(__tstate);
15783 if (PyErr_Occurred()) SWIG_fail;
15784 }
15785 resultobj = SWIG_Py_Void();
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15793 PyObject *resultobj = 0;
15794 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15795 bool result;
15796 void *argp1 = 0 ;
15797 int res1 = 0 ;
15798 PyObject *swig_obj[1] ;
15799
15800 if (!args) SWIG_fail;
15801 swig_obj[0] = args;
15802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15803 if (!SWIG_IsOK(res1)) {
15804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15805 }
15806 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15810 wxPyEndAllowThreads(__tstate);
15811 if (PyErr_Occurred()) SWIG_fail;
15812 }
15813 {
15814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15815 }
15816 return resultobj;
15817 fail:
15818 return NULL;
15819 }
15820
15821
15822 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15823 PyObject *resultobj = 0;
15824 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15825 bool result;
15826 void *argp1 = 0 ;
15827 int res1 = 0 ;
15828 PyObject *swig_obj[1] ;
15829
15830 if (!args) SWIG_fail;
15831 swig_obj[0] = args;
15832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15833 if (!SWIG_IsOK(res1)) {
15834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15835 }
15836 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15837 {
15838 PyThreadState* __tstate = wxPyBeginAllowThreads();
15839 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15840 wxPyEndAllowThreads(__tstate);
15841 if (PyErr_Occurred()) SWIG_fail;
15842 }
15843 {
15844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15845 }
15846 return resultobj;
15847 fail:
15848 return NULL;
15849 }
15850
15851
15852 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15853 PyObject *resultobj = 0;
15854 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15855 bool result;
15856 void *argp1 = 0 ;
15857 int res1 = 0 ;
15858 PyObject *swig_obj[1] ;
15859
15860 if (!args) SWIG_fail;
15861 swig_obj[0] = args;
15862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15863 if (!SWIG_IsOK(res1)) {
15864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15865 }
15866 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15867 {
15868 PyThreadState* __tstate = wxPyBeginAllowThreads();
15869 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15870 wxPyEndAllowThreads(__tstate);
15871 if (PyErr_Occurred()) SWIG_fail;
15872 }
15873 {
15874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15875 }
15876 return resultobj;
15877 fail:
15878 return NULL;
15879 }
15880
15881
15882 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15883 PyObject *resultobj = 0;
15884 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15885 int arg2 = (int) wxJOY_BUTTON_ANY ;
15886 bool result;
15887 void *argp1 = 0 ;
15888 int res1 = 0 ;
15889 int val2 ;
15890 int ecode2 = 0 ;
15891 PyObject * obj0 = 0 ;
15892 PyObject * obj1 = 0 ;
15893 char * kwnames[] = {
15894 (char *) "self",(char *) "but", NULL
15895 };
15896
15897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15899 if (!SWIG_IsOK(res1)) {
15900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15901 }
15902 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15903 if (obj1) {
15904 ecode2 = SWIG_AsVal_int(obj1, &val2);
15905 if (!SWIG_IsOK(ecode2)) {
15906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15907 }
15908 arg2 = static_cast< int >(val2);
15909 }
15910 {
15911 PyThreadState* __tstate = wxPyBeginAllowThreads();
15912 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15913 wxPyEndAllowThreads(__tstate);
15914 if (PyErr_Occurred()) SWIG_fail;
15915 }
15916 {
15917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15918 }
15919 return resultobj;
15920 fail:
15921 return NULL;
15922 }
15923
15924
15925 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15926 PyObject *resultobj = 0;
15927 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15928 int arg2 = (int) wxJOY_BUTTON_ANY ;
15929 bool result;
15930 void *argp1 = 0 ;
15931 int res1 = 0 ;
15932 int val2 ;
15933 int ecode2 = 0 ;
15934 PyObject * obj0 = 0 ;
15935 PyObject * obj1 = 0 ;
15936 char * kwnames[] = {
15937 (char *) "self",(char *) "but", NULL
15938 };
15939
15940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15942 if (!SWIG_IsOK(res1)) {
15943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15944 }
15945 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15946 if (obj1) {
15947 ecode2 = SWIG_AsVal_int(obj1, &val2);
15948 if (!SWIG_IsOK(ecode2)) {
15949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15950 }
15951 arg2 = static_cast< int >(val2);
15952 }
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 {
15960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15961 }
15962 return resultobj;
15963 fail:
15964 return NULL;
15965 }
15966
15967
15968 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15969 PyObject *resultobj = 0;
15970 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15971 int arg2 = (int) wxJOY_BUTTON_ANY ;
15972 bool result;
15973 void *argp1 = 0 ;
15974 int res1 = 0 ;
15975 int val2 ;
15976 int ecode2 = 0 ;
15977 PyObject * obj0 = 0 ;
15978 PyObject * obj1 = 0 ;
15979 char * kwnames[] = {
15980 (char *) "self",(char *) "but", NULL
15981 };
15982
15983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15985 if (!SWIG_IsOK(res1)) {
15986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15987 }
15988 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15989 if (obj1) {
15990 ecode2 = SWIG_AsVal_int(obj1, &val2);
15991 if (!SWIG_IsOK(ecode2)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15993 }
15994 arg2 = static_cast< int >(val2);
15995 }
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 {
16003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16004 }
16005 return resultobj;
16006 fail:
16007 return NULL;
16008 }
16009
16010
16011 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16012 PyObject *obj;
16013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16014 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16015 return SWIG_Py_Void();
16016 }
16017
16018 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16019 return SWIG_Python_InitShadowInstance(args);
16020 }
16021
16022 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj = 0;
16024 wxString const &arg1_defvalue = wxPyEmptyString ;
16025 wxString *arg1 = (wxString *) &arg1_defvalue ;
16026 wxSound *result = 0 ;
16027 bool temp1 = false ;
16028 PyObject * obj0 = 0 ;
16029 char * kwnames[] = {
16030 (char *) "fileName", NULL
16031 };
16032
16033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16034 if (obj0) {
16035 {
16036 arg1 = wxString_in_helper(obj0);
16037 if (arg1 == NULL) SWIG_fail;
16038 temp1 = true;
16039 }
16040 }
16041 {
16042 if (!wxPyCheckForApp()) SWIG_fail;
16043 PyThreadState* __tstate = wxPyBeginAllowThreads();
16044 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16049 {
16050 if (temp1)
16051 delete arg1;
16052 }
16053 return resultobj;
16054 fail:
16055 {
16056 if (temp1)
16057 delete arg1;
16058 }
16059 return NULL;
16060 }
16061
16062
16063 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16064 PyObject *resultobj = 0;
16065 PyObject *arg1 = (PyObject *) 0 ;
16066 wxSound *result = 0 ;
16067 PyObject * obj0 = 0 ;
16068 char * kwnames[] = {
16069 (char *) "data", NULL
16070 };
16071
16072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16073 arg1 = obj0;
16074 {
16075 if (!wxPyCheckForApp()) SWIG_fail;
16076 PyThreadState* __tstate = wxPyBeginAllowThreads();
16077 result = (wxSound *)new_wxSound(arg1);
16078 wxPyEndAllowThreads(__tstate);
16079 if (PyErr_Occurred()) SWIG_fail;
16080 }
16081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16082 return resultobj;
16083 fail:
16084 return NULL;
16085 }
16086
16087
16088 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16089 PyObject *resultobj = 0;
16090 wxSound *arg1 = (wxSound *) 0 ;
16091 void *argp1 = 0 ;
16092 int res1 = 0 ;
16093 PyObject *swig_obj[1] ;
16094
16095 if (!args) SWIG_fail;
16096 swig_obj[0] = args;
16097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16098 if (!SWIG_IsOK(res1)) {
16099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16100 }
16101 arg1 = reinterpret_cast< wxSound * >(argp1);
16102 {
16103 PyThreadState* __tstate = wxPyBeginAllowThreads();
16104 delete arg1;
16105
16106 wxPyEndAllowThreads(__tstate);
16107 if (PyErr_Occurred()) SWIG_fail;
16108 }
16109 resultobj = SWIG_Py_Void();
16110 return resultobj;
16111 fail:
16112 return NULL;
16113 }
16114
16115
16116 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16117 PyObject *resultobj = 0;
16118 wxSound *arg1 = (wxSound *) 0 ;
16119 wxString *arg2 = 0 ;
16120 bool result;
16121 void *argp1 = 0 ;
16122 int res1 = 0 ;
16123 bool temp2 = false ;
16124 PyObject * obj0 = 0 ;
16125 PyObject * obj1 = 0 ;
16126 char * kwnames[] = {
16127 (char *) "self",(char *) "fileName", NULL
16128 };
16129
16130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
16131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16132 if (!SWIG_IsOK(res1)) {
16133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
16134 }
16135 arg1 = reinterpret_cast< wxSound * >(argp1);
16136 {
16137 arg2 = wxString_in_helper(obj1);
16138 if (arg2 == NULL) SWIG_fail;
16139 temp2 = true;
16140 }
16141 {
16142 PyThreadState* __tstate = wxPyBeginAllowThreads();
16143 result = (bool)(arg1)->Create((wxString const &)*arg2);
16144 wxPyEndAllowThreads(__tstate);
16145 if (PyErr_Occurred()) SWIG_fail;
16146 }
16147 {
16148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16149 }
16150 {
16151 if (temp2)
16152 delete arg2;
16153 }
16154 return resultobj;
16155 fail:
16156 {
16157 if (temp2)
16158 delete arg2;
16159 }
16160 return NULL;
16161 }
16162
16163
16164 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16165 PyObject *resultobj = 0;
16166 wxSound *arg1 = (wxSound *) 0 ;
16167 PyObject *arg2 = (PyObject *) 0 ;
16168 bool result;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 PyObject * obj0 = 0 ;
16172 PyObject * obj1 = 0 ;
16173 char * kwnames[] = {
16174 (char *) "self",(char *) "data", NULL
16175 };
16176
16177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16179 if (!SWIG_IsOK(res1)) {
16180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16181 }
16182 arg1 = reinterpret_cast< wxSound * >(argp1);
16183 arg2 = obj1;
16184 {
16185 PyThreadState* __tstate = wxPyBeginAllowThreads();
16186 result = (bool)wxSound_CreateFromData(arg1,arg2);
16187 wxPyEndAllowThreads(__tstate);
16188 if (PyErr_Occurred()) SWIG_fail;
16189 }
16190 {
16191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16192 }
16193 return resultobj;
16194 fail:
16195 return NULL;
16196 }
16197
16198
16199 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16200 PyObject *resultobj = 0;
16201 wxSound *arg1 = (wxSound *) 0 ;
16202 bool result;
16203 void *argp1 = 0 ;
16204 int res1 = 0 ;
16205 PyObject *swig_obj[1] ;
16206
16207 if (!args) SWIG_fail;
16208 swig_obj[0] = args;
16209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16210 if (!SWIG_IsOK(res1)) {
16211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16212 }
16213 arg1 = reinterpret_cast< wxSound * >(argp1);
16214 {
16215 PyThreadState* __tstate = wxPyBeginAllowThreads();
16216 result = (bool)(arg1)->IsOk();
16217 wxPyEndAllowThreads(__tstate);
16218 if (PyErr_Occurred()) SWIG_fail;
16219 }
16220 {
16221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16222 }
16223 return resultobj;
16224 fail:
16225 return NULL;
16226 }
16227
16228
16229 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj = 0;
16231 wxSound *arg1 = (wxSound *) 0 ;
16232 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16233 bool result;
16234 void *argp1 = 0 ;
16235 int res1 = 0 ;
16236 unsigned int val2 ;
16237 int ecode2 = 0 ;
16238 PyObject * obj0 = 0 ;
16239 PyObject * obj1 = 0 ;
16240 char * kwnames[] = {
16241 (char *) "self",(char *) "flags", NULL
16242 };
16243
16244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16246 if (!SWIG_IsOK(res1)) {
16247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16248 }
16249 arg1 = reinterpret_cast< wxSound * >(argp1);
16250 if (obj1) {
16251 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16252 if (!SWIG_IsOK(ecode2)) {
16253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16254 }
16255 arg2 = static_cast< unsigned int >(val2);
16256 }
16257 {
16258 if (!wxPyCheckForApp()) SWIG_fail;
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = (bool)((wxSound const *)arg1)->Play(arg2);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 {
16265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16266 }
16267 return resultobj;
16268 fail:
16269 return NULL;
16270 }
16271
16272
16273 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16274 PyObject *resultobj = 0;
16275 wxString *arg1 = 0 ;
16276 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16277 bool result;
16278 bool temp1 = false ;
16279 unsigned int val2 ;
16280 int ecode2 = 0 ;
16281 PyObject * obj0 = 0 ;
16282 PyObject * obj1 = 0 ;
16283 char * kwnames[] = {
16284 (char *) "filename",(char *) "flags", NULL
16285 };
16286
16287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16288 {
16289 arg1 = wxString_in_helper(obj0);
16290 if (arg1 == NULL) SWIG_fail;
16291 temp1 = true;
16292 }
16293 if (obj1) {
16294 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16295 if (!SWIG_IsOK(ecode2)) {
16296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16297 }
16298 arg2 = static_cast< unsigned int >(val2);
16299 }
16300 {
16301 if (!wxPyCheckForApp()) SWIG_fail;
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16304 wxPyEndAllowThreads(__tstate);
16305 if (PyErr_Occurred()) SWIG_fail;
16306 }
16307 {
16308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16309 }
16310 {
16311 if (temp1)
16312 delete arg1;
16313 }
16314 return resultobj;
16315 fail:
16316 {
16317 if (temp1)
16318 delete arg1;
16319 }
16320 return NULL;
16321 }
16322
16323
16324 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16325 PyObject *resultobj = 0;
16326
16327 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16328 {
16329 if (!wxPyCheckForApp()) SWIG_fail;
16330 PyThreadState* __tstate = wxPyBeginAllowThreads();
16331 wxSound::Stop();
16332 wxPyEndAllowThreads(__tstate);
16333 if (PyErr_Occurred()) SWIG_fail;
16334 }
16335 resultobj = SWIG_Py_Void();
16336 return resultobj;
16337 fail:
16338 return NULL;
16339 }
16340
16341
16342 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16343 PyObject *obj;
16344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16345 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16346 return SWIG_Py_Void();
16347 }
16348
16349 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16350 return SWIG_Python_InitShadowInstance(args);
16351 }
16352
16353 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16354 PyObject *resultobj = 0;
16355 wxString *arg1 = 0 ;
16356 wxString *arg2 = 0 ;
16357 wxString *arg3 = 0 ;
16358 wxString *arg4 = 0 ;
16359 wxFileTypeInfo *result = 0 ;
16360 bool temp1 = false ;
16361 bool temp2 = false ;
16362 bool temp3 = false ;
16363 bool temp4 = false ;
16364 PyObject * obj0 = 0 ;
16365 PyObject * obj1 = 0 ;
16366 PyObject * obj2 = 0 ;
16367 PyObject * obj3 = 0 ;
16368 char * kwnames[] = {
16369 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16370 };
16371
16372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16373 {
16374 arg1 = wxString_in_helper(obj0);
16375 if (arg1 == NULL) SWIG_fail;
16376 temp1 = true;
16377 }
16378 {
16379 arg2 = wxString_in_helper(obj1);
16380 if (arg2 == NULL) SWIG_fail;
16381 temp2 = true;
16382 }
16383 {
16384 arg3 = wxString_in_helper(obj2);
16385 if (arg3 == NULL) SWIG_fail;
16386 temp3 = true;
16387 }
16388 {
16389 arg4 = wxString_in_helper(obj3);
16390 if (arg4 == NULL) SWIG_fail;
16391 temp4 = true;
16392 }
16393 {
16394 PyThreadState* __tstate = wxPyBeginAllowThreads();
16395 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16396 wxPyEndAllowThreads(__tstate);
16397 if (PyErr_Occurred()) SWIG_fail;
16398 }
16399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16400 {
16401 if (temp1)
16402 delete arg1;
16403 }
16404 {
16405 if (temp2)
16406 delete arg2;
16407 }
16408 {
16409 if (temp3)
16410 delete arg3;
16411 }
16412 {
16413 if (temp4)
16414 delete arg4;
16415 }
16416 return resultobj;
16417 fail:
16418 {
16419 if (temp1)
16420 delete arg1;
16421 }
16422 {
16423 if (temp2)
16424 delete arg2;
16425 }
16426 {
16427 if (temp3)
16428 delete arg3;
16429 }
16430 {
16431 if (temp4)
16432 delete arg4;
16433 }
16434 return NULL;
16435 }
16436
16437
16438 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16439 PyObject *resultobj = 0;
16440 wxArrayString *arg1 = 0 ;
16441 wxFileTypeInfo *result = 0 ;
16442 bool temp1 = false ;
16443 PyObject * obj0 = 0 ;
16444 char * kwnames[] = {
16445 (char *) "sArray", NULL
16446 };
16447
16448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16449 {
16450 if (! PySequence_Check(obj0)) {
16451 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16452 SWIG_fail;
16453 }
16454 arg1 = new wxArrayString;
16455 temp1 = true;
16456 int i, len=PySequence_Length(obj0);
16457 for (i=0; i<len; i++) {
16458 PyObject* item = PySequence_GetItem(obj0, i);
16459 wxString* s = wxString_in_helper(item);
16460 if (PyErr_Occurred()) SWIG_fail;
16461 arg1->Add(*s);
16462 delete s;
16463 Py_DECREF(item);
16464 }
16465 }
16466 {
16467 PyThreadState* __tstate = wxPyBeginAllowThreads();
16468 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16469 wxPyEndAllowThreads(__tstate);
16470 if (PyErr_Occurred()) SWIG_fail;
16471 }
16472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16473 {
16474 if (temp1) delete arg1;
16475 }
16476 return resultobj;
16477 fail:
16478 {
16479 if (temp1) delete arg1;
16480 }
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16486 PyObject *resultobj = 0;
16487 wxFileTypeInfo *result = 0 ;
16488
16489 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16504 PyObject *resultobj = 0;
16505 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16506 bool result;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 PyObject *swig_obj[1] ;
16510
16511 if (!args) SWIG_fail;
16512 swig_obj[0] = args;
16513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16514 if (!SWIG_IsOK(res1)) {
16515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16516 }
16517 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16518 {
16519 PyThreadState* __tstate = wxPyBeginAllowThreads();
16520 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj = 0;
16535 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16536 wxString *arg2 = 0 ;
16537 int arg3 = (int) 0 ;
16538 void *argp1 = 0 ;
16539 int res1 = 0 ;
16540 bool temp2 = false ;
16541 int val3 ;
16542 int ecode3 = 0 ;
16543 PyObject * obj0 = 0 ;
16544 PyObject * obj1 = 0 ;
16545 PyObject * obj2 = 0 ;
16546 char * kwnames[] = {
16547 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16548 };
16549
16550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16552 if (!SWIG_IsOK(res1)) {
16553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16554 }
16555 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16556 {
16557 arg2 = wxString_in_helper(obj1);
16558 if (arg2 == NULL) SWIG_fail;
16559 temp2 = true;
16560 }
16561 if (obj2) {
16562 ecode3 = SWIG_AsVal_int(obj2, &val3);
16563 if (!SWIG_IsOK(ecode3)) {
16564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16565 }
16566 arg3 = static_cast< int >(val3);
16567 }
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 resultobj = SWIG_Py_Void();
16575 {
16576 if (temp2)
16577 delete arg2;
16578 }
16579 return resultobj;
16580 fail:
16581 {
16582 if (temp2)
16583 delete arg2;
16584 }
16585 return NULL;
16586 }
16587
16588
16589 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16590 PyObject *resultobj = 0;
16591 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16592 wxString *arg2 = 0 ;
16593 void *argp1 = 0 ;
16594 int res1 = 0 ;
16595 bool temp2 = false ;
16596 PyObject * obj0 = 0 ;
16597 PyObject * obj1 = 0 ;
16598 char * kwnames[] = {
16599 (char *) "self",(char *) "shortDesc", NULL
16600 };
16601
16602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16604 if (!SWIG_IsOK(res1)) {
16605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16606 }
16607 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16608 {
16609 arg2 = wxString_in_helper(obj1);
16610 if (arg2 == NULL) SWIG_fail;
16611 temp2 = true;
16612 }
16613 {
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 (arg1)->SetShortDesc((wxString const &)*arg2);
16616 wxPyEndAllowThreads(__tstate);
16617 if (PyErr_Occurred()) SWIG_fail;
16618 }
16619 resultobj = SWIG_Py_Void();
16620 {
16621 if (temp2)
16622 delete arg2;
16623 }
16624 return resultobj;
16625 fail:
16626 {
16627 if (temp2)
16628 delete arg2;
16629 }
16630 return NULL;
16631 }
16632
16633
16634 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16635 PyObject *resultobj = 0;
16636 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16637 wxString *result = 0 ;
16638 void *argp1 = 0 ;
16639 int res1 = 0 ;
16640 PyObject *swig_obj[1] ;
16641
16642 if (!args) SWIG_fail;
16643 swig_obj[0] = args;
16644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16645 if (!SWIG_IsOK(res1)) {
16646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16647 }
16648 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16649 {
16650 PyThreadState* __tstate = wxPyBeginAllowThreads();
16651 {
16652 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16653 result = (wxString *) &_result_ref;
16654 }
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 {
16659 #if wxUSE_UNICODE
16660 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16661 #else
16662 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16663 #endif
16664 }
16665 return resultobj;
16666 fail:
16667 return NULL;
16668 }
16669
16670
16671 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16672 PyObject *resultobj = 0;
16673 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16674 wxString *result = 0 ;
16675 void *argp1 = 0 ;
16676 int res1 = 0 ;
16677 PyObject *swig_obj[1] ;
16678
16679 if (!args) SWIG_fail;
16680 swig_obj[0] = args;
16681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16682 if (!SWIG_IsOK(res1)) {
16683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16684 }
16685 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16686 {
16687 PyThreadState* __tstate = wxPyBeginAllowThreads();
16688 {
16689 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16690 result = (wxString *) &_result_ref;
16691 }
16692 wxPyEndAllowThreads(__tstate);
16693 if (PyErr_Occurred()) SWIG_fail;
16694 }
16695 {
16696 #if wxUSE_UNICODE
16697 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16698 #else
16699 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16700 #endif
16701 }
16702 return resultobj;
16703 fail:
16704 return NULL;
16705 }
16706
16707
16708 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16709 PyObject *resultobj = 0;
16710 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16711 wxString *result = 0 ;
16712 void *argp1 = 0 ;
16713 int res1 = 0 ;
16714 PyObject *swig_obj[1] ;
16715
16716 if (!args) SWIG_fail;
16717 swig_obj[0] = args;
16718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16719 if (!SWIG_IsOK(res1)) {
16720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16721 }
16722 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16723 {
16724 PyThreadState* __tstate = wxPyBeginAllowThreads();
16725 {
16726 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16727 result = (wxString *) &_result_ref;
16728 }
16729 wxPyEndAllowThreads(__tstate);
16730 if (PyErr_Occurred()) SWIG_fail;
16731 }
16732 {
16733 #if wxUSE_UNICODE
16734 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16735 #else
16736 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16737 #endif
16738 }
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16746 PyObject *resultobj = 0;
16747 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16748 wxString *result = 0 ;
16749 void *argp1 = 0 ;
16750 int res1 = 0 ;
16751 PyObject *swig_obj[1] ;
16752
16753 if (!args) SWIG_fail;
16754 swig_obj[0] = args;
16755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16756 if (!SWIG_IsOK(res1)) {
16757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16758 }
16759 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 {
16763 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16764 result = (wxString *) &_result_ref;
16765 }
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 {
16770 #if wxUSE_UNICODE
16771 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16772 #else
16773 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16774 #endif
16775 }
16776 return resultobj;
16777 fail:
16778 return NULL;
16779 }
16780
16781
16782 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16783 PyObject *resultobj = 0;
16784 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16785 wxString *result = 0 ;
16786 void *argp1 = 0 ;
16787 int res1 = 0 ;
16788 PyObject *swig_obj[1] ;
16789
16790 if (!args) SWIG_fail;
16791 swig_obj[0] = args;
16792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16793 if (!SWIG_IsOK(res1)) {
16794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16795 }
16796 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16797 {
16798 PyThreadState* __tstate = wxPyBeginAllowThreads();
16799 {
16800 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16801 result = (wxString *) &_result_ref;
16802 }
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 {
16807 #if wxUSE_UNICODE
16808 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16809 #else
16810 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16811 #endif
16812 }
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16820 PyObject *resultobj = 0;
16821 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16822 wxArrayString *result = 0 ;
16823 void *argp1 = 0 ;
16824 int res1 = 0 ;
16825 PyObject *swig_obj[1] ;
16826
16827 if (!args) SWIG_fail;
16828 swig_obj[0] = args;
16829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16830 if (!SWIG_IsOK(res1)) {
16831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16832 }
16833 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16834 {
16835 PyThreadState* __tstate = wxPyBeginAllowThreads();
16836 {
16837 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16838 result = (wxArrayString *) &_result_ref;
16839 }
16840 wxPyEndAllowThreads(__tstate);
16841 if (PyErr_Occurred()) SWIG_fail;
16842 }
16843 {
16844 resultobj = wxArrayString2PyList_helper(*result);
16845 }
16846 return resultobj;
16847 fail:
16848 return NULL;
16849 }
16850
16851
16852 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16853 PyObject *resultobj = 0;
16854 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16855 size_t result;
16856 void *argp1 = 0 ;
16857 int res1 = 0 ;
16858 PyObject *swig_obj[1] ;
16859
16860 if (!args) SWIG_fail;
16861 swig_obj[0] = args;
16862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16863 if (!SWIG_IsOK(res1)) {
16864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16865 }
16866 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16881 PyObject *resultobj = 0;
16882 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16883 wxString *result = 0 ;
16884 void *argp1 = 0 ;
16885 int res1 = 0 ;
16886 PyObject *swig_obj[1] ;
16887
16888 if (!args) SWIG_fail;
16889 swig_obj[0] = args;
16890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16893 }
16894 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 {
16898 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16899 result = (wxString *) &_result_ref;
16900 }
16901 wxPyEndAllowThreads(__tstate);
16902 if (PyErr_Occurred()) SWIG_fail;
16903 }
16904 {
16905 #if wxUSE_UNICODE
16906 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16907 #else
16908 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16909 #endif
16910 }
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16918 PyObject *resultobj = 0;
16919 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16920 int result;
16921 void *argp1 = 0 ;
16922 int res1 = 0 ;
16923 PyObject *swig_obj[1] ;
16924
16925 if (!args) SWIG_fail;
16926 swig_obj[0] = args;
16927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16928 if (!SWIG_IsOK(res1)) {
16929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16930 }
16931 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16932 {
16933 PyThreadState* __tstate = wxPyBeginAllowThreads();
16934 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16935 wxPyEndAllowThreads(__tstate);
16936 if (PyErr_Occurred()) SWIG_fail;
16937 }
16938 resultobj = SWIG_From_int(static_cast< int >(result));
16939 return resultobj;
16940 fail:
16941 return NULL;
16942 }
16943
16944
16945 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16946 PyObject *obj;
16947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16948 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16949 return SWIG_Py_Void();
16950 }
16951
16952 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16953 return SWIG_Python_InitShadowInstance(args);
16954 }
16955
16956 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj = 0;
16958 wxFileTypeInfo *arg1 = 0 ;
16959 wxFileType *result = 0 ;
16960 void *argp1 = 0 ;
16961 int res1 = 0 ;
16962 PyObject * obj0 = 0 ;
16963 char * kwnames[] = {
16964 (char *) "ftInfo", NULL
16965 };
16966
16967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16968 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16969 if (!SWIG_IsOK(res1)) {
16970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16971 }
16972 if (!argp1) {
16973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16974 }
16975 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16976 {
16977 PyThreadState* __tstate = wxPyBeginAllowThreads();
16978 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16979 wxPyEndAllowThreads(__tstate);
16980 if (PyErr_Occurred()) SWIG_fail;
16981 }
16982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16983 return resultobj;
16984 fail:
16985 return NULL;
16986 }
16987
16988
16989 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16990 PyObject *resultobj = 0;
16991 wxFileType *arg1 = (wxFileType *) 0 ;
16992 void *argp1 = 0 ;
16993 int res1 = 0 ;
16994 PyObject *swig_obj[1] ;
16995
16996 if (!args) SWIG_fail;
16997 swig_obj[0] = args;
16998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16999 if (!SWIG_IsOK(res1)) {
17000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17001 }
17002 arg1 = reinterpret_cast< wxFileType * >(argp1);
17003 {
17004 PyThreadState* __tstate = wxPyBeginAllowThreads();
17005 delete arg1;
17006
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 resultobj = SWIG_Py_Void();
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17018 PyObject *resultobj = 0;
17019 wxFileType *arg1 = (wxFileType *) 0 ;
17020 PyObject *result = 0 ;
17021 void *argp1 = 0 ;
17022 int res1 = 0 ;
17023 PyObject *swig_obj[1] ;
17024
17025 if (!args) SWIG_fail;
17026 swig_obj[0] = args;
17027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17028 if (!SWIG_IsOK(res1)) {
17029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17030 }
17031 arg1 = reinterpret_cast< wxFileType * >(argp1);
17032 {
17033 PyThreadState* __tstate = wxPyBeginAllowThreads();
17034 result = (PyObject *)wxFileType_GetMimeType(arg1);
17035 wxPyEndAllowThreads(__tstate);
17036 if (PyErr_Occurred()) SWIG_fail;
17037 }
17038 resultobj = result;
17039 return resultobj;
17040 fail:
17041 return NULL;
17042 }
17043
17044
17045 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17046 PyObject *resultobj = 0;
17047 wxFileType *arg1 = (wxFileType *) 0 ;
17048 PyObject *result = 0 ;
17049 void *argp1 = 0 ;
17050 int res1 = 0 ;
17051 PyObject *swig_obj[1] ;
17052
17053 if (!args) SWIG_fail;
17054 swig_obj[0] = args;
17055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17056 if (!SWIG_IsOK(res1)) {
17057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17058 }
17059 arg1 = reinterpret_cast< wxFileType * >(argp1);
17060 {
17061 PyThreadState* __tstate = wxPyBeginAllowThreads();
17062 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17063 wxPyEndAllowThreads(__tstate);
17064 if (PyErr_Occurred()) SWIG_fail;
17065 }
17066 resultobj = result;
17067 return resultobj;
17068 fail:
17069 return NULL;
17070 }
17071
17072
17073 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17074 PyObject *resultobj = 0;
17075 wxFileType *arg1 = (wxFileType *) 0 ;
17076 PyObject *result = 0 ;
17077 void *argp1 = 0 ;
17078 int res1 = 0 ;
17079 PyObject *swig_obj[1] ;
17080
17081 if (!args) SWIG_fail;
17082 swig_obj[0] = args;
17083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17084 if (!SWIG_IsOK(res1)) {
17085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17086 }
17087 arg1 = reinterpret_cast< wxFileType * >(argp1);
17088 {
17089 PyThreadState* __tstate = wxPyBeginAllowThreads();
17090 result = (PyObject *)wxFileType_GetExtensions(arg1);
17091 wxPyEndAllowThreads(__tstate);
17092 if (PyErr_Occurred()) SWIG_fail;
17093 }
17094 resultobj = result;
17095 return resultobj;
17096 fail:
17097 return NULL;
17098 }
17099
17100
17101 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17102 PyObject *resultobj = 0;
17103 wxFileType *arg1 = (wxFileType *) 0 ;
17104 wxIcon *result = 0 ;
17105 void *argp1 = 0 ;
17106 int res1 = 0 ;
17107 PyObject *swig_obj[1] ;
17108
17109 if (!args) SWIG_fail;
17110 swig_obj[0] = args;
17111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17112 if (!SWIG_IsOK(res1)) {
17113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17114 }
17115 arg1 = reinterpret_cast< wxFileType * >(argp1);
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 result = (wxIcon *)wxFileType_GetIcon(arg1);
17119 wxPyEndAllowThreads(__tstate);
17120 if (PyErr_Occurred()) SWIG_fail;
17121 }
17122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
17123 return resultobj;
17124 fail:
17125 return NULL;
17126 }
17127
17128
17129 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17130 PyObject *resultobj = 0;
17131 wxFileType *arg1 = (wxFileType *) 0 ;
17132 PyObject *result = 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_wxFileType, 0 | 0 );
17140 if (!SWIG_IsOK(res1)) {
17141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
17142 }
17143 arg1 = reinterpret_cast< wxFileType * >(argp1);
17144 {
17145 PyThreadState* __tstate = wxPyBeginAllowThreads();
17146 result = (PyObject *)wxFileType_GetIconInfo(arg1);
17147 wxPyEndAllowThreads(__tstate);
17148 if (PyErr_Occurred()) SWIG_fail;
17149 }
17150 resultobj = result;
17151 return resultobj;
17152 fail:
17153 return NULL;
17154 }
17155
17156
17157 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17158 PyObject *resultobj = 0;
17159 wxFileType *arg1 = (wxFileType *) 0 ;
17160 PyObject *result = 0 ;
17161 void *argp1 = 0 ;
17162 int res1 = 0 ;
17163 PyObject *swig_obj[1] ;
17164
17165 if (!args) SWIG_fail;
17166 swig_obj[0] = args;
17167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17168 if (!SWIG_IsOK(res1)) {
17169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17170 }
17171 arg1 = reinterpret_cast< wxFileType * >(argp1);
17172 {
17173 PyThreadState* __tstate = wxPyBeginAllowThreads();
17174 result = (PyObject *)wxFileType_GetDescription(arg1);
17175 wxPyEndAllowThreads(__tstate);
17176 if (PyErr_Occurred()) SWIG_fail;
17177 }
17178 resultobj = result;
17179 return resultobj;
17180 fail:
17181 return NULL;
17182 }
17183
17184
17185 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17186 PyObject *resultobj = 0;
17187 wxFileType *arg1 = (wxFileType *) 0 ;
17188 wxString *arg2 = 0 ;
17189 wxString const &arg3_defvalue = wxPyEmptyString ;
17190 wxString *arg3 = (wxString *) &arg3_defvalue ;
17191 PyObject *result = 0 ;
17192 void *argp1 = 0 ;
17193 int res1 = 0 ;
17194 bool temp2 = false ;
17195 bool temp3 = false ;
17196 PyObject * obj0 = 0 ;
17197 PyObject * obj1 = 0 ;
17198 PyObject * obj2 = 0 ;
17199 char * kwnames[] = {
17200 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17201 };
17202
17203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17205 if (!SWIG_IsOK(res1)) {
17206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17207 }
17208 arg1 = reinterpret_cast< wxFileType * >(argp1);
17209 {
17210 arg2 = wxString_in_helper(obj1);
17211 if (arg2 == NULL) SWIG_fail;
17212 temp2 = true;
17213 }
17214 if (obj2) {
17215 {
17216 arg3 = wxString_in_helper(obj2);
17217 if (arg3 == NULL) SWIG_fail;
17218 temp3 = true;
17219 }
17220 }
17221 {
17222 PyThreadState* __tstate = wxPyBeginAllowThreads();
17223 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17224 wxPyEndAllowThreads(__tstate);
17225 if (PyErr_Occurred()) SWIG_fail;
17226 }
17227 resultobj = result;
17228 {
17229 if (temp2)
17230 delete arg2;
17231 }
17232 {
17233 if (temp3)
17234 delete arg3;
17235 }
17236 return resultobj;
17237 fail:
17238 {
17239 if (temp2)
17240 delete arg2;
17241 }
17242 {
17243 if (temp3)
17244 delete arg3;
17245 }
17246 return NULL;
17247 }
17248
17249
17250 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17251 PyObject *resultobj = 0;
17252 wxFileType *arg1 = (wxFileType *) 0 ;
17253 wxString *arg2 = 0 ;
17254 wxString const &arg3_defvalue = wxPyEmptyString ;
17255 wxString *arg3 = (wxString *) &arg3_defvalue ;
17256 PyObject *result = 0 ;
17257 void *argp1 = 0 ;
17258 int res1 = 0 ;
17259 bool temp2 = false ;
17260 bool temp3 = false ;
17261 PyObject * obj0 = 0 ;
17262 PyObject * obj1 = 0 ;
17263 PyObject * obj2 = 0 ;
17264 char * kwnames[] = {
17265 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17266 };
17267
17268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17270 if (!SWIG_IsOK(res1)) {
17271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17272 }
17273 arg1 = reinterpret_cast< wxFileType * >(argp1);
17274 {
17275 arg2 = wxString_in_helper(obj1);
17276 if (arg2 == NULL) SWIG_fail;
17277 temp2 = true;
17278 }
17279 if (obj2) {
17280 {
17281 arg3 = wxString_in_helper(obj2);
17282 if (arg3 == NULL) SWIG_fail;
17283 temp3 = true;
17284 }
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 resultobj = result;
17293 {
17294 if (temp2)
17295 delete arg2;
17296 }
17297 {
17298 if (temp3)
17299 delete arg3;
17300 }
17301 return resultobj;
17302 fail:
17303 {
17304 if (temp2)
17305 delete arg2;
17306 }
17307 {
17308 if (temp3)
17309 delete arg3;
17310 }
17311 return NULL;
17312 }
17313
17314
17315 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17316 PyObject *resultobj = 0;
17317 wxFileType *arg1 = (wxFileType *) 0 ;
17318 wxString *arg2 = 0 ;
17319 wxString const &arg3_defvalue = wxPyEmptyString ;
17320 wxString *arg3 = (wxString *) &arg3_defvalue ;
17321 PyObject *result = 0 ;
17322 void *argp1 = 0 ;
17323 int res1 = 0 ;
17324 bool temp2 = false ;
17325 bool temp3 = false ;
17326 PyObject * obj0 = 0 ;
17327 PyObject * obj1 = 0 ;
17328 PyObject * obj2 = 0 ;
17329 char * kwnames[] = {
17330 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17331 };
17332
17333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17335 if (!SWIG_IsOK(res1)) {
17336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17337 }
17338 arg1 = reinterpret_cast< wxFileType * >(argp1);
17339 {
17340 arg2 = wxString_in_helper(obj1);
17341 if (arg2 == NULL) SWIG_fail;
17342 temp2 = true;
17343 }
17344 if (obj2) {
17345 {
17346 arg3 = wxString_in_helper(obj2);
17347 if (arg3 == NULL) SWIG_fail;
17348 temp3 = true;
17349 }
17350 }
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17354 wxPyEndAllowThreads(__tstate);
17355 if (PyErr_Occurred()) SWIG_fail;
17356 }
17357 resultobj = result;
17358 {
17359 if (temp2)
17360 delete arg2;
17361 }
17362 {
17363 if (temp3)
17364 delete arg3;
17365 }
17366 return resultobj;
17367 fail:
17368 {
17369 if (temp2)
17370 delete arg2;
17371 }
17372 {
17373 if (temp3)
17374 delete arg3;
17375 }
17376 return NULL;
17377 }
17378
17379
17380 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj = 0;
17382 wxFileType *arg1 = (wxFileType *) 0 ;
17383 wxString *arg2 = 0 ;
17384 wxString *arg3 = 0 ;
17385 bool arg4 = (bool) true ;
17386 bool result;
17387 void *argp1 = 0 ;
17388 int res1 = 0 ;
17389 bool temp2 = false ;
17390 bool temp3 = false ;
17391 bool val4 ;
17392 int ecode4 = 0 ;
17393 PyObject * obj0 = 0 ;
17394 PyObject * obj1 = 0 ;
17395 PyObject * obj2 = 0 ;
17396 PyObject * obj3 = 0 ;
17397 char * kwnames[] = {
17398 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17399 };
17400
17401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17403 if (!SWIG_IsOK(res1)) {
17404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17405 }
17406 arg1 = reinterpret_cast< wxFileType * >(argp1);
17407 {
17408 arg2 = wxString_in_helper(obj1);
17409 if (arg2 == NULL) SWIG_fail;
17410 temp2 = true;
17411 }
17412 {
17413 arg3 = wxString_in_helper(obj2);
17414 if (arg3 == NULL) SWIG_fail;
17415 temp3 = true;
17416 }
17417 if (obj3) {
17418 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17419 if (!SWIG_IsOK(ecode4)) {
17420 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17421 }
17422 arg4 = static_cast< bool >(val4);
17423 }
17424 {
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17427 wxPyEndAllowThreads(__tstate);
17428 if (PyErr_Occurred()) SWIG_fail;
17429 }
17430 {
17431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17432 }
17433 {
17434 if (temp2)
17435 delete arg2;
17436 }
17437 {
17438 if (temp3)
17439 delete arg3;
17440 }
17441 return resultobj;
17442 fail:
17443 {
17444 if (temp2)
17445 delete arg2;
17446 }
17447 {
17448 if (temp3)
17449 delete arg3;
17450 }
17451 return NULL;
17452 }
17453
17454
17455 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17456 PyObject *resultobj = 0;
17457 wxFileType *arg1 = (wxFileType *) 0 ;
17458 wxString const &arg2_defvalue = wxPyEmptyString ;
17459 wxString *arg2 = (wxString *) &arg2_defvalue ;
17460 int arg3 = (int) 0 ;
17461 bool result;
17462 void *argp1 = 0 ;
17463 int res1 = 0 ;
17464 bool temp2 = false ;
17465 int val3 ;
17466 int ecode3 = 0 ;
17467 PyObject * obj0 = 0 ;
17468 PyObject * obj1 = 0 ;
17469 PyObject * obj2 = 0 ;
17470 char * kwnames[] = {
17471 (char *) "self",(char *) "cmd",(char *) "index", NULL
17472 };
17473
17474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17476 if (!SWIG_IsOK(res1)) {
17477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17478 }
17479 arg1 = reinterpret_cast< wxFileType * >(argp1);
17480 if (obj1) {
17481 {
17482 arg2 = wxString_in_helper(obj1);
17483 if (arg2 == NULL) SWIG_fail;
17484 temp2 = true;
17485 }
17486 }
17487 if (obj2) {
17488 ecode3 = SWIG_AsVal_int(obj2, &val3);
17489 if (!SWIG_IsOK(ecode3)) {
17490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17491 }
17492 arg3 = static_cast< int >(val3);
17493 }
17494 {
17495 PyThreadState* __tstate = wxPyBeginAllowThreads();
17496 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17497 wxPyEndAllowThreads(__tstate);
17498 if (PyErr_Occurred()) SWIG_fail;
17499 }
17500 {
17501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17502 }
17503 {
17504 if (temp2)
17505 delete arg2;
17506 }
17507 return resultobj;
17508 fail:
17509 {
17510 if (temp2)
17511 delete arg2;
17512 }
17513 return NULL;
17514 }
17515
17516
17517 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17518 PyObject *resultobj = 0;
17519 wxFileType *arg1 = (wxFileType *) 0 ;
17520 bool result;
17521 void *argp1 = 0 ;
17522 int res1 = 0 ;
17523 PyObject *swig_obj[1] ;
17524
17525 if (!args) SWIG_fail;
17526 swig_obj[0] = args;
17527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17528 if (!SWIG_IsOK(res1)) {
17529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17530 }
17531 arg1 = reinterpret_cast< wxFileType * >(argp1);
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = (bool)(arg1)->Unassociate();
17535 wxPyEndAllowThreads(__tstate);
17536 if (PyErr_Occurred()) SWIG_fail;
17537 }
17538 {
17539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17540 }
17541 return resultobj;
17542 fail:
17543 return NULL;
17544 }
17545
17546
17547 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17548 PyObject *resultobj = 0;
17549 wxString *arg1 = 0 ;
17550 wxString *arg2 = 0 ;
17551 wxString const &arg3_defvalue = wxPyEmptyString ;
17552 wxString *arg3 = (wxString *) &arg3_defvalue ;
17553 wxString result;
17554 bool temp1 = false ;
17555 bool temp2 = false ;
17556 bool temp3 = false ;
17557 PyObject * obj0 = 0 ;
17558 PyObject * obj1 = 0 ;
17559 PyObject * obj2 = 0 ;
17560 char * kwnames[] = {
17561 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17562 };
17563
17564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17565 {
17566 arg1 = wxString_in_helper(obj0);
17567 if (arg1 == NULL) SWIG_fail;
17568 temp1 = true;
17569 }
17570 {
17571 arg2 = wxString_in_helper(obj1);
17572 if (arg2 == NULL) SWIG_fail;
17573 temp2 = true;
17574 }
17575 if (obj2) {
17576 {
17577 arg3 = wxString_in_helper(obj2);
17578 if (arg3 == NULL) SWIG_fail;
17579 temp3 = true;
17580 }
17581 }
17582 {
17583 PyThreadState* __tstate = wxPyBeginAllowThreads();
17584 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 #if wxUSE_UNICODE
17590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17591 #else
17592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17593 #endif
17594 }
17595 {
17596 if (temp1)
17597 delete arg1;
17598 }
17599 {
17600 if (temp2)
17601 delete arg2;
17602 }
17603 {
17604 if (temp3)
17605 delete arg3;
17606 }
17607 return resultobj;
17608 fail:
17609 {
17610 if (temp1)
17611 delete arg1;
17612 }
17613 {
17614 if (temp2)
17615 delete arg2;
17616 }
17617 {
17618 if (temp3)
17619 delete arg3;
17620 }
17621 return NULL;
17622 }
17623
17624
17625 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17626 PyObject *obj;
17627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17628 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17629 return SWIG_Py_Void();
17630 }
17631
17632 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17633 return SWIG_Python_InitShadowInstance(args);
17634 }
17635
17636 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17637 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17638 return 1;
17639 }
17640
17641
17642 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17643 PyObject *pyobj = 0;
17644
17645 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17646 return pyobj;
17647 }
17648
17649
17650 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17651 PyObject *resultobj = 0;
17652 wxString *arg1 = 0 ;
17653 wxString *arg2 = 0 ;
17654 bool result;
17655 bool temp1 = false ;
17656 bool temp2 = false ;
17657 PyObject * obj0 = 0 ;
17658 PyObject * obj1 = 0 ;
17659 char * kwnames[] = {
17660 (char *) "mimeType",(char *) "wildcard", NULL
17661 };
17662
17663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17664 {
17665 arg1 = wxString_in_helper(obj0);
17666 if (arg1 == NULL) SWIG_fail;
17667 temp1 = true;
17668 }
17669 {
17670 arg2 = wxString_in_helper(obj1);
17671 if (arg2 == NULL) SWIG_fail;
17672 temp2 = true;
17673 }
17674 {
17675 PyThreadState* __tstate = wxPyBeginAllowThreads();
17676 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17677 wxPyEndAllowThreads(__tstate);
17678 if (PyErr_Occurred()) SWIG_fail;
17679 }
17680 {
17681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17682 }
17683 {
17684 if (temp1)
17685 delete arg1;
17686 }
17687 {
17688 if (temp2)
17689 delete arg2;
17690 }
17691 return resultobj;
17692 fail:
17693 {
17694 if (temp1)
17695 delete arg1;
17696 }
17697 {
17698 if (temp2)
17699 delete arg2;
17700 }
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17706 PyObject *resultobj = 0;
17707 wxMimeTypesManager *result = 0 ;
17708
17709 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17710 {
17711 PyThreadState* __tstate = wxPyBeginAllowThreads();
17712 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17713 wxPyEndAllowThreads(__tstate);
17714 if (PyErr_Occurred()) SWIG_fail;
17715 }
17716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17717 return resultobj;
17718 fail:
17719 return NULL;
17720 }
17721
17722
17723 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj = 0;
17725 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17726 int arg2 = (int) wxMAILCAP_ALL ;
17727 wxString const &arg3_defvalue = wxPyEmptyString ;
17728 wxString *arg3 = (wxString *) &arg3_defvalue ;
17729 void *argp1 = 0 ;
17730 int res1 = 0 ;
17731 int val2 ;
17732 int ecode2 = 0 ;
17733 bool temp3 = false ;
17734 PyObject * obj0 = 0 ;
17735 PyObject * obj1 = 0 ;
17736 PyObject * obj2 = 0 ;
17737 char * kwnames[] = {
17738 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17739 };
17740
17741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17743 if (!SWIG_IsOK(res1)) {
17744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17745 }
17746 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17747 if (obj1) {
17748 ecode2 = SWIG_AsVal_int(obj1, &val2);
17749 if (!SWIG_IsOK(ecode2)) {
17750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17751 }
17752 arg2 = static_cast< int >(val2);
17753 }
17754 if (obj2) {
17755 {
17756 arg3 = wxString_in_helper(obj2);
17757 if (arg3 == NULL) SWIG_fail;
17758 temp3 = true;
17759 }
17760 }
17761 {
17762 PyThreadState* __tstate = wxPyBeginAllowThreads();
17763 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17764 wxPyEndAllowThreads(__tstate);
17765 if (PyErr_Occurred()) SWIG_fail;
17766 }
17767 resultobj = SWIG_Py_Void();
17768 {
17769 if (temp3)
17770 delete arg3;
17771 }
17772 return resultobj;
17773 fail:
17774 {
17775 if (temp3)
17776 delete arg3;
17777 }
17778 return NULL;
17779 }
17780
17781
17782 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17783 PyObject *resultobj = 0;
17784 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17785 void *argp1 = 0 ;
17786 int res1 = 0 ;
17787 PyObject *swig_obj[1] ;
17788
17789 if (!args) SWIG_fail;
17790 swig_obj[0] = args;
17791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17792 if (!SWIG_IsOK(res1)) {
17793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17794 }
17795 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17796 {
17797 PyThreadState* __tstate = wxPyBeginAllowThreads();
17798 (arg1)->ClearData();
17799 wxPyEndAllowThreads(__tstate);
17800 if (PyErr_Occurred()) SWIG_fail;
17801 }
17802 resultobj = SWIG_Py_Void();
17803 return resultobj;
17804 fail:
17805 return NULL;
17806 }
17807
17808
17809 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj = 0;
17811 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17812 wxString *arg2 = 0 ;
17813 wxFileType *result = 0 ;
17814 void *argp1 = 0 ;
17815 int res1 = 0 ;
17816 bool temp2 = false ;
17817 PyObject * obj0 = 0 ;
17818 PyObject * obj1 = 0 ;
17819 char * kwnames[] = {
17820 (char *) "self",(char *) "ext", NULL
17821 };
17822
17823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17825 if (!SWIG_IsOK(res1)) {
17826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17827 }
17828 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17829 {
17830 arg2 = wxString_in_helper(obj1);
17831 if (arg2 == NULL) SWIG_fail;
17832 temp2 = true;
17833 }
17834 {
17835 PyThreadState* __tstate = wxPyBeginAllowThreads();
17836 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17841 {
17842 if (temp2)
17843 delete arg2;
17844 }
17845 return resultobj;
17846 fail:
17847 {
17848 if (temp2)
17849 delete arg2;
17850 }
17851 return NULL;
17852 }
17853
17854
17855 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17856 PyObject *resultobj = 0;
17857 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17858 wxString *arg2 = 0 ;
17859 wxFileType *result = 0 ;
17860 void *argp1 = 0 ;
17861 int res1 = 0 ;
17862 bool temp2 = false ;
17863 PyObject * obj0 = 0 ;
17864 PyObject * obj1 = 0 ;
17865 char * kwnames[] = {
17866 (char *) "self",(char *) "mimeType", NULL
17867 };
17868
17869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17871 if (!SWIG_IsOK(res1)) {
17872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17873 }
17874 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17875 {
17876 arg2 = wxString_in_helper(obj1);
17877 if (arg2 == NULL) SWIG_fail;
17878 temp2 = true;
17879 }
17880 {
17881 PyThreadState* __tstate = wxPyBeginAllowThreads();
17882 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17883 wxPyEndAllowThreads(__tstate);
17884 if (PyErr_Occurred()) SWIG_fail;
17885 }
17886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17887 {
17888 if (temp2)
17889 delete arg2;
17890 }
17891 return resultobj;
17892 fail:
17893 {
17894 if (temp2)
17895 delete arg2;
17896 }
17897 return NULL;
17898 }
17899
17900
17901 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17902 PyObject *resultobj = 0;
17903 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17904 wxString *arg2 = 0 ;
17905 bool arg3 = (bool) false ;
17906 bool result;
17907 void *argp1 = 0 ;
17908 int res1 = 0 ;
17909 bool temp2 = false ;
17910 bool val3 ;
17911 int ecode3 = 0 ;
17912 PyObject * obj0 = 0 ;
17913 PyObject * obj1 = 0 ;
17914 PyObject * obj2 = 0 ;
17915 char * kwnames[] = {
17916 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17917 };
17918
17919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17921 if (!SWIG_IsOK(res1)) {
17922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17923 }
17924 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17925 {
17926 arg2 = wxString_in_helper(obj1);
17927 if (arg2 == NULL) SWIG_fail;
17928 temp2 = true;
17929 }
17930 if (obj2) {
17931 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17932 if (!SWIG_IsOK(ecode3)) {
17933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17934 }
17935 arg3 = static_cast< bool >(val3);
17936 }
17937 {
17938 PyThreadState* __tstate = wxPyBeginAllowThreads();
17939 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 {
17944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17945 }
17946 {
17947 if (temp2)
17948 delete arg2;
17949 }
17950 return resultobj;
17951 fail:
17952 {
17953 if (temp2)
17954 delete arg2;
17955 }
17956 return NULL;
17957 }
17958
17959
17960 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17961 PyObject *resultobj = 0;
17962 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17963 wxString *arg2 = 0 ;
17964 bool result;
17965 void *argp1 = 0 ;
17966 int res1 = 0 ;
17967 bool temp2 = false ;
17968 PyObject * obj0 = 0 ;
17969 PyObject * obj1 = 0 ;
17970 char * kwnames[] = {
17971 (char *) "self",(char *) "filename", NULL
17972 };
17973
17974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17976 if (!SWIG_IsOK(res1)) {
17977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17978 }
17979 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17980 {
17981 arg2 = wxString_in_helper(obj1);
17982 if (arg2 == NULL) SWIG_fail;
17983 temp2 = true;
17984 }
17985 {
17986 PyThreadState* __tstate = wxPyBeginAllowThreads();
17987 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 {
17992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17993 }
17994 {
17995 if (temp2)
17996 delete arg2;
17997 }
17998 return resultobj;
17999 fail:
18000 {
18001 if (temp2)
18002 delete arg2;
18003 }
18004 return NULL;
18005 }
18006
18007
18008 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18009 PyObject *resultobj = 0;
18010 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18011 PyObject *result = 0 ;
18012 void *argp1 = 0 ;
18013 int res1 = 0 ;
18014 PyObject *swig_obj[1] ;
18015
18016 if (!args) SWIG_fail;
18017 swig_obj[0] = args;
18018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18019 if (!SWIG_IsOK(res1)) {
18020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18021 }
18022 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18023 {
18024 PyThreadState* __tstate = wxPyBeginAllowThreads();
18025 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18026 wxPyEndAllowThreads(__tstate);
18027 if (PyErr_Occurred()) SWIG_fail;
18028 }
18029 resultobj = result;
18030 return resultobj;
18031 fail:
18032 return NULL;
18033 }
18034
18035
18036 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18037 PyObject *resultobj = 0;
18038 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18039 wxFileTypeInfo *arg2 = 0 ;
18040 void *argp1 = 0 ;
18041 int res1 = 0 ;
18042 void *argp2 = 0 ;
18043 int res2 = 0 ;
18044 PyObject * obj0 = 0 ;
18045 PyObject * obj1 = 0 ;
18046 char * kwnames[] = {
18047 (char *) "self",(char *) "ft", NULL
18048 };
18049
18050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18052 if (!SWIG_IsOK(res1)) {
18053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18054 }
18055 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18056 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18057 if (!SWIG_IsOK(res2)) {
18058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18059 }
18060 if (!argp2) {
18061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18062 }
18063 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18064 {
18065 PyThreadState* __tstate = wxPyBeginAllowThreads();
18066 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18067 wxPyEndAllowThreads(__tstate);
18068 if (PyErr_Occurred()) SWIG_fail;
18069 }
18070 resultobj = SWIG_Py_Void();
18071 return resultobj;
18072 fail:
18073 return NULL;
18074 }
18075
18076
18077 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18078 PyObject *resultobj = 0;
18079 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18080 wxFileTypeInfo *arg2 = 0 ;
18081 wxFileType *result = 0 ;
18082 void *argp1 = 0 ;
18083 int res1 = 0 ;
18084 void *argp2 = 0 ;
18085 int res2 = 0 ;
18086 PyObject * obj0 = 0 ;
18087 PyObject * obj1 = 0 ;
18088 char * kwnames[] = {
18089 (char *) "self",(char *) "ftInfo", NULL
18090 };
18091
18092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18094 if (!SWIG_IsOK(res1)) {
18095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18096 }
18097 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18099 if (!SWIG_IsOK(res2)) {
18100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18101 }
18102 if (!argp2) {
18103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18104 }
18105 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18106 {
18107 PyThreadState* __tstate = wxPyBeginAllowThreads();
18108 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
18109 wxPyEndAllowThreads(__tstate);
18110 if (PyErr_Occurred()) SWIG_fail;
18111 }
18112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18113 return resultobj;
18114 fail:
18115 return NULL;
18116 }
18117
18118
18119 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18120 PyObject *resultobj = 0;
18121 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18122 wxFileType *arg2 = (wxFileType *) 0 ;
18123 bool result;
18124 void *argp1 = 0 ;
18125 int res1 = 0 ;
18126 void *argp2 = 0 ;
18127 int res2 = 0 ;
18128 PyObject * obj0 = 0 ;
18129 PyObject * obj1 = 0 ;
18130 char * kwnames[] = {
18131 (char *) "self",(char *) "ft", NULL
18132 };
18133
18134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
18135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18136 if (!SWIG_IsOK(res1)) {
18137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18138 }
18139 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
18141 if (!SWIG_IsOK(res2)) {
18142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
18143 }
18144 arg2 = reinterpret_cast< wxFileType * >(argp2);
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 result = (bool)(arg1)->Unassociate(arg2);
18148 wxPyEndAllowThreads(__tstate);
18149 if (PyErr_Occurred()) SWIG_fail;
18150 }
18151 {
18152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18153 }
18154 return resultobj;
18155 fail:
18156 return NULL;
18157 }
18158
18159
18160 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18161 PyObject *resultobj = 0;
18162 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18163 void *argp1 = 0 ;
18164 int res1 = 0 ;
18165 PyObject *swig_obj[1] ;
18166
18167 if (!args) SWIG_fail;
18168 swig_obj[0] = args;
18169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18170 if (!SWIG_IsOK(res1)) {
18171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18172 }
18173 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 delete arg1;
18177
18178 wxPyEndAllowThreads(__tstate);
18179 if (PyErr_Occurred()) SWIG_fail;
18180 }
18181 resultobj = SWIG_Py_Void();
18182 return resultobj;
18183 fail:
18184 return NULL;
18185 }
18186
18187
18188 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18189 PyObject *obj;
18190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18191 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18192 return SWIG_Py_Void();
18193 }
18194
18195 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18196 return SWIG_Python_InitShadowInstance(args);
18197 }
18198
18199 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18200 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18201 return 1;
18202 }
18203
18204
18205 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18206 PyObject *pyobj = 0;
18207
18208 {
18209 #if wxUSE_UNICODE
18210 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18211 #else
18212 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18213 #endif
18214 }
18215 return pyobj;
18216 }
18217
18218
18219 SWIGINTERN int ART_MENU_set(PyObject *) {
18220 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18221 return 1;
18222 }
18223
18224
18225 SWIGINTERN PyObject *ART_MENU_get(void) {
18226 PyObject *pyobj = 0;
18227
18228 {
18229 #if wxUSE_UNICODE
18230 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18231 #else
18232 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18233 #endif
18234 }
18235 return pyobj;
18236 }
18237
18238
18239 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18240 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18241 return 1;
18242 }
18243
18244
18245 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18246 PyObject *pyobj = 0;
18247
18248 {
18249 #if wxUSE_UNICODE
18250 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18251 #else
18252 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18253 #endif
18254 }
18255 return pyobj;
18256 }
18257
18258
18259 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18260 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18261 return 1;
18262 }
18263
18264
18265 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18266 PyObject *pyobj = 0;
18267
18268 {
18269 #if wxUSE_UNICODE
18270 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18271 #else
18272 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18273 #endif
18274 }
18275 return pyobj;
18276 }
18277
18278
18279 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18280 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18281 return 1;
18282 }
18283
18284
18285 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18286 PyObject *pyobj = 0;
18287
18288 {
18289 #if wxUSE_UNICODE
18290 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18291 #else
18292 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18293 #endif
18294 }
18295 return pyobj;
18296 }
18297
18298
18299 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18300 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18301 return 1;
18302 }
18303
18304
18305 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18306 PyObject *pyobj = 0;
18307
18308 {
18309 #if wxUSE_UNICODE
18310 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18311 #else
18312 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18313 #endif
18314 }
18315 return pyobj;
18316 }
18317
18318
18319 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18320 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18321 return 1;
18322 }
18323
18324
18325 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18326 PyObject *pyobj = 0;
18327
18328 {
18329 #if wxUSE_UNICODE
18330 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18331 #else
18332 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18333 #endif
18334 }
18335 return pyobj;
18336 }
18337
18338
18339 SWIGINTERN int ART_OTHER_set(PyObject *) {
18340 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18341 return 1;
18342 }
18343
18344
18345 SWIGINTERN PyObject *ART_OTHER_get(void) {
18346 PyObject *pyobj = 0;
18347
18348 {
18349 #if wxUSE_UNICODE
18350 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18351 #else
18352 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18353 #endif
18354 }
18355 return pyobj;
18356 }
18357
18358
18359 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18360 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18361 return 1;
18362 }
18363
18364
18365 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18366 PyObject *pyobj = 0;
18367
18368 {
18369 #if wxUSE_UNICODE
18370 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18371 #else
18372 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18373 #endif
18374 }
18375 return pyobj;
18376 }
18377
18378
18379 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18380 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18381 return 1;
18382 }
18383
18384
18385 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18386 PyObject *pyobj = 0;
18387
18388 {
18389 #if wxUSE_UNICODE
18390 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18391 #else
18392 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18393 #endif
18394 }
18395 return pyobj;
18396 }
18397
18398
18399 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18400 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18401 return 1;
18402 }
18403
18404
18405 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18406 PyObject *pyobj = 0;
18407
18408 {
18409 #if wxUSE_UNICODE
18410 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18411 #else
18412 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18413 #endif
18414 }
18415 return pyobj;
18416 }
18417
18418
18419 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18420 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18421 return 1;
18422 }
18423
18424
18425 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18426 PyObject *pyobj = 0;
18427
18428 {
18429 #if wxUSE_UNICODE
18430 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18431 #else
18432 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18433 #endif
18434 }
18435 return pyobj;
18436 }
18437
18438
18439 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18440 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18441 return 1;
18442 }
18443
18444
18445 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18446 PyObject *pyobj = 0;
18447
18448 {
18449 #if wxUSE_UNICODE
18450 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18451 #else
18452 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18453 #endif
18454 }
18455 return pyobj;
18456 }
18457
18458
18459 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18460 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18461 return 1;
18462 }
18463
18464
18465 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18466 PyObject *pyobj = 0;
18467
18468 {
18469 #if wxUSE_UNICODE
18470 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18471 #else
18472 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18473 #endif
18474 }
18475 return pyobj;
18476 }
18477
18478
18479 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18480 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18481 return 1;
18482 }
18483
18484
18485 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18486 PyObject *pyobj = 0;
18487
18488 {
18489 #if wxUSE_UNICODE
18490 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18491 #else
18492 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18493 #endif
18494 }
18495 return pyobj;
18496 }
18497
18498
18499 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18500 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18501 return 1;
18502 }
18503
18504
18505 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18506 PyObject *pyobj = 0;
18507
18508 {
18509 #if wxUSE_UNICODE
18510 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18511 #else
18512 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18513 #endif
18514 }
18515 return pyobj;
18516 }
18517
18518
18519 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18520 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18521 return 1;
18522 }
18523
18524
18525 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18526 PyObject *pyobj = 0;
18527
18528 {
18529 #if wxUSE_UNICODE
18530 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18531 #else
18532 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18533 #endif
18534 }
18535 return pyobj;
18536 }
18537
18538
18539 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18540 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18541 return 1;
18542 }
18543
18544
18545 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18546 PyObject *pyobj = 0;
18547
18548 {
18549 #if wxUSE_UNICODE
18550 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18551 #else
18552 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18553 #endif
18554 }
18555 return pyobj;
18556 }
18557
18558
18559 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18560 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18561 return 1;
18562 }
18563
18564
18565 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18566 PyObject *pyobj = 0;
18567
18568 {
18569 #if wxUSE_UNICODE
18570 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18571 #else
18572 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18573 #endif
18574 }
18575 return pyobj;
18576 }
18577
18578
18579 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18580 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18581 return 1;
18582 }
18583
18584
18585 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18586 PyObject *pyobj = 0;
18587
18588 {
18589 #if wxUSE_UNICODE
18590 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18591 #else
18592 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18593 #endif
18594 }
18595 return pyobj;
18596 }
18597
18598
18599 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18600 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18601 return 1;
18602 }
18603
18604
18605 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18606 PyObject *pyobj = 0;
18607
18608 {
18609 #if wxUSE_UNICODE
18610 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18611 #else
18612 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18613 #endif
18614 }
18615 return pyobj;
18616 }
18617
18618
18619 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18620 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18621 return 1;
18622 }
18623
18624
18625 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18626 PyObject *pyobj = 0;
18627
18628 {
18629 #if wxUSE_UNICODE
18630 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18631 #else
18632 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18633 #endif
18634 }
18635 return pyobj;
18636 }
18637
18638
18639 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18640 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18641 return 1;
18642 }
18643
18644
18645 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18646 PyObject *pyobj = 0;
18647
18648 {
18649 #if wxUSE_UNICODE
18650 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18651 #else
18652 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18653 #endif
18654 }
18655 return pyobj;
18656 }
18657
18658
18659 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18660 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18661 return 1;
18662 }
18663
18664
18665 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18666 PyObject *pyobj = 0;
18667
18668 {
18669 #if wxUSE_UNICODE
18670 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18671 #else
18672 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18673 #endif
18674 }
18675 return pyobj;
18676 }
18677
18678
18679 SWIGINTERN int ART_PRINT_set(PyObject *) {
18680 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18681 return 1;
18682 }
18683
18684
18685 SWIGINTERN PyObject *ART_PRINT_get(void) {
18686 PyObject *pyobj = 0;
18687
18688 {
18689 #if wxUSE_UNICODE
18690 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18691 #else
18692 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18693 #endif
18694 }
18695 return pyobj;
18696 }
18697
18698
18699 SWIGINTERN int ART_HELP_set(PyObject *) {
18700 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18701 return 1;
18702 }
18703
18704
18705 SWIGINTERN PyObject *ART_HELP_get(void) {
18706 PyObject *pyobj = 0;
18707
18708 {
18709 #if wxUSE_UNICODE
18710 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18711 #else
18712 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18713 #endif
18714 }
18715 return pyobj;
18716 }
18717
18718
18719 SWIGINTERN int ART_TIP_set(PyObject *) {
18720 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18721 return 1;
18722 }
18723
18724
18725 SWIGINTERN PyObject *ART_TIP_get(void) {
18726 PyObject *pyobj = 0;
18727
18728 {
18729 #if wxUSE_UNICODE
18730 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18731 #else
18732 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18733 #endif
18734 }
18735 return pyobj;
18736 }
18737
18738
18739 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18740 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18741 return 1;
18742 }
18743
18744
18745 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18746 PyObject *pyobj = 0;
18747
18748 {
18749 #if wxUSE_UNICODE
18750 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18751 #else
18752 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18753 #endif
18754 }
18755 return pyobj;
18756 }
18757
18758
18759 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18760 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18761 return 1;
18762 }
18763
18764
18765 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18766 PyObject *pyobj = 0;
18767
18768 {
18769 #if wxUSE_UNICODE
18770 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18771 #else
18772 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18773 #endif
18774 }
18775 return pyobj;
18776 }
18777
18778
18779 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18780 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18781 return 1;
18782 }
18783
18784
18785 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18786 PyObject *pyobj = 0;
18787
18788 {
18789 #if wxUSE_UNICODE
18790 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18791 #else
18792 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18793 #endif
18794 }
18795 return pyobj;
18796 }
18797
18798
18799 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18800 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18801 return 1;
18802 }
18803
18804
18805 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18806 PyObject *pyobj = 0;
18807
18808 {
18809 #if wxUSE_UNICODE
18810 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18811 #else
18812 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18813 #endif
18814 }
18815 return pyobj;
18816 }
18817
18818
18819 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18820 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18821 return 1;
18822 }
18823
18824
18825 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18826 PyObject *pyobj = 0;
18827
18828 {
18829 #if wxUSE_UNICODE
18830 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18831 #else
18832 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18833 #endif
18834 }
18835 return pyobj;
18836 }
18837
18838
18839 SWIGINTERN int ART_CDROM_set(PyObject *) {
18840 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18841 return 1;
18842 }
18843
18844
18845 SWIGINTERN PyObject *ART_CDROM_get(void) {
18846 PyObject *pyobj = 0;
18847
18848 {
18849 #if wxUSE_UNICODE
18850 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18851 #else
18852 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18853 #endif
18854 }
18855 return pyobj;
18856 }
18857
18858
18859 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18860 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18861 return 1;
18862 }
18863
18864
18865 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18866 PyObject *pyobj = 0;
18867
18868 {
18869 #if wxUSE_UNICODE
18870 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18871 #else
18872 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18873 #endif
18874 }
18875 return pyobj;
18876 }
18877
18878
18879 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18880 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18881 return 1;
18882 }
18883
18884
18885 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18886 PyObject *pyobj = 0;
18887
18888 {
18889 #if wxUSE_UNICODE
18890 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18891 #else
18892 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18893 #endif
18894 }
18895 return pyobj;
18896 }
18897
18898
18899 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18900 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18901 return 1;
18902 }
18903
18904
18905 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18906 PyObject *pyobj = 0;
18907
18908 {
18909 #if wxUSE_UNICODE
18910 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18911 #else
18912 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18913 #endif
18914 }
18915 return pyobj;
18916 }
18917
18918
18919 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18920 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18921 return 1;
18922 }
18923
18924
18925 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18926 PyObject *pyobj = 0;
18927
18928 {
18929 #if wxUSE_UNICODE
18930 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18931 #else
18932 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18933 #endif
18934 }
18935 return pyobj;
18936 }
18937
18938
18939 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18940 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18941 return 1;
18942 }
18943
18944
18945 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18946 PyObject *pyobj = 0;
18947
18948 {
18949 #if wxUSE_UNICODE
18950 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18951 #else
18952 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18953 #endif
18954 }
18955 return pyobj;
18956 }
18957
18958
18959 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18960 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18961 return 1;
18962 }
18963
18964
18965 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18966 PyObject *pyobj = 0;
18967
18968 {
18969 #if wxUSE_UNICODE
18970 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18971 #else
18972 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18973 #endif
18974 }
18975 return pyobj;
18976 }
18977
18978
18979 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18980 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18981 return 1;
18982 }
18983
18984
18985 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18986 PyObject *pyobj = 0;
18987
18988 {
18989 #if wxUSE_UNICODE
18990 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18991 #else
18992 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18993 #endif
18994 }
18995 return pyobj;
18996 }
18997
18998
18999 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19000 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19001 return 1;
19002 }
19003
19004
19005 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19006 PyObject *pyobj = 0;
19007
19008 {
19009 #if wxUSE_UNICODE
19010 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19011 #else
19012 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19013 #endif
19014 }
19015 return pyobj;
19016 }
19017
19018
19019 SWIGINTERN int ART_ERROR_set(PyObject *) {
19020 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19021 return 1;
19022 }
19023
19024
19025 SWIGINTERN PyObject *ART_ERROR_get(void) {
19026 PyObject *pyobj = 0;
19027
19028 {
19029 #if wxUSE_UNICODE
19030 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19031 #else
19032 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19033 #endif
19034 }
19035 return pyobj;
19036 }
19037
19038
19039 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19040 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19041 return 1;
19042 }
19043
19044
19045 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19046 PyObject *pyobj = 0;
19047
19048 {
19049 #if wxUSE_UNICODE
19050 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19051 #else
19052 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19053 #endif
19054 }
19055 return pyobj;
19056 }
19057
19058
19059 SWIGINTERN int ART_WARNING_set(PyObject *) {
19060 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19061 return 1;
19062 }
19063
19064
19065 SWIGINTERN PyObject *ART_WARNING_get(void) {
19066 PyObject *pyobj = 0;
19067
19068 {
19069 #if wxUSE_UNICODE
19070 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19071 #else
19072 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19073 #endif
19074 }
19075 return pyobj;
19076 }
19077
19078
19079 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19080 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19081 return 1;
19082 }
19083
19084
19085 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19086 PyObject *pyobj = 0;
19087
19088 {
19089 #if wxUSE_UNICODE
19090 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19091 #else
19092 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19093 #endif
19094 }
19095 return pyobj;
19096 }
19097
19098
19099 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19100 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19101 return 1;
19102 }
19103
19104
19105 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19106 PyObject *pyobj = 0;
19107
19108 {
19109 #if wxUSE_UNICODE
19110 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19111 #else
19112 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19113 #endif
19114 }
19115 return pyobj;
19116 }
19117
19118
19119 SWIGINTERN int ART_COPY_set(PyObject *) {
19120 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
19121 return 1;
19122 }
19123
19124
19125 SWIGINTERN PyObject *ART_COPY_get(void) {
19126 PyObject *pyobj = 0;
19127
19128 {
19129 #if wxUSE_UNICODE
19130 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19131 #else
19132 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19133 #endif
19134 }
19135 return pyobj;
19136 }
19137
19138
19139 SWIGINTERN int ART_CUT_set(PyObject *) {
19140 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
19141 return 1;
19142 }
19143
19144
19145 SWIGINTERN PyObject *ART_CUT_get(void) {
19146 PyObject *pyobj = 0;
19147
19148 {
19149 #if wxUSE_UNICODE
19150 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19151 #else
19152 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19153 #endif
19154 }
19155 return pyobj;
19156 }
19157
19158
19159 SWIGINTERN int ART_PASTE_set(PyObject *) {
19160 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
19161 return 1;
19162 }
19163
19164
19165 SWIGINTERN PyObject *ART_PASTE_get(void) {
19166 PyObject *pyobj = 0;
19167
19168 {
19169 #if wxUSE_UNICODE
19170 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19171 #else
19172 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19173 #endif
19174 }
19175 return pyobj;
19176 }
19177
19178
19179 SWIGINTERN int ART_DELETE_set(PyObject *) {
19180 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19181 return 1;
19182 }
19183
19184
19185 SWIGINTERN PyObject *ART_DELETE_get(void) {
19186 PyObject *pyobj = 0;
19187
19188 {
19189 #if wxUSE_UNICODE
19190 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19191 #else
19192 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19193 #endif
19194 }
19195 return pyobj;
19196 }
19197
19198
19199 SWIGINTERN int ART_NEW_set(PyObject *) {
19200 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19201 return 1;
19202 }
19203
19204
19205 SWIGINTERN PyObject *ART_NEW_get(void) {
19206 PyObject *pyobj = 0;
19207
19208 {
19209 #if wxUSE_UNICODE
19210 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19211 #else
19212 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19213 #endif
19214 }
19215 return pyobj;
19216 }
19217
19218
19219 SWIGINTERN int ART_UNDO_set(PyObject *) {
19220 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19221 return 1;
19222 }
19223
19224
19225 SWIGINTERN PyObject *ART_UNDO_get(void) {
19226 PyObject *pyobj = 0;
19227
19228 {
19229 #if wxUSE_UNICODE
19230 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19231 #else
19232 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19233 #endif
19234 }
19235 return pyobj;
19236 }
19237
19238
19239 SWIGINTERN int ART_REDO_set(PyObject *) {
19240 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19241 return 1;
19242 }
19243
19244
19245 SWIGINTERN PyObject *ART_REDO_get(void) {
19246 PyObject *pyobj = 0;
19247
19248 {
19249 #if wxUSE_UNICODE
19250 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19251 #else
19252 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19253 #endif
19254 }
19255 return pyobj;
19256 }
19257
19258
19259 SWIGINTERN int ART_QUIT_set(PyObject *) {
19260 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19261 return 1;
19262 }
19263
19264
19265 SWIGINTERN PyObject *ART_QUIT_get(void) {
19266 PyObject *pyobj = 0;
19267
19268 {
19269 #if wxUSE_UNICODE
19270 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19271 #else
19272 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19273 #endif
19274 }
19275 return pyobj;
19276 }
19277
19278
19279 SWIGINTERN int ART_FIND_set(PyObject *) {
19280 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19281 return 1;
19282 }
19283
19284
19285 SWIGINTERN PyObject *ART_FIND_get(void) {
19286 PyObject *pyobj = 0;
19287
19288 {
19289 #if wxUSE_UNICODE
19290 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19291 #else
19292 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19293 #endif
19294 }
19295 return pyobj;
19296 }
19297
19298
19299 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19300 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19301 return 1;
19302 }
19303
19304
19305 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19306 PyObject *pyobj = 0;
19307
19308 {
19309 #if wxUSE_UNICODE
19310 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19311 #else
19312 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19313 #endif
19314 }
19315 return pyobj;
19316 }
19317
19318
19319 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19320 PyObject *resultobj = 0;
19321 wxPyArtProvider *result = 0 ;
19322
19323 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19324 {
19325 if (!wxPyCheckForApp()) SWIG_fail;
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 result = (wxPyArtProvider *)new wxPyArtProvider();
19328 wxPyEndAllowThreads(__tstate);
19329 if (PyErr_Occurred()) SWIG_fail;
19330 }
19331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19332 return resultobj;
19333 fail:
19334 return NULL;
19335 }
19336
19337
19338 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19339 PyObject *resultobj = 0;
19340 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19341 void *argp1 = 0 ;
19342 int res1 = 0 ;
19343 PyObject *swig_obj[1] ;
19344
19345 if (!args) SWIG_fail;
19346 swig_obj[0] = args;
19347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19348 if (!SWIG_IsOK(res1)) {
19349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19350 }
19351 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19352 {
19353 PyThreadState* __tstate = wxPyBeginAllowThreads();
19354 delete arg1;
19355
19356 wxPyEndAllowThreads(__tstate);
19357 if (PyErr_Occurred()) SWIG_fail;
19358 }
19359 resultobj = SWIG_Py_Void();
19360 return resultobj;
19361 fail:
19362 return NULL;
19363 }
19364
19365
19366 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19367 PyObject *resultobj = 0;
19368 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19369 PyObject *arg2 = (PyObject *) 0 ;
19370 PyObject *arg3 = (PyObject *) 0 ;
19371 void *argp1 = 0 ;
19372 int res1 = 0 ;
19373 PyObject * obj0 = 0 ;
19374 PyObject * obj1 = 0 ;
19375 PyObject * obj2 = 0 ;
19376 char * kwnames[] = {
19377 (char *) "self",(char *) "self",(char *) "_class", NULL
19378 };
19379
19380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19382 if (!SWIG_IsOK(res1)) {
19383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19384 }
19385 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19386 arg2 = obj1;
19387 arg3 = obj2;
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 (arg1)->_setCallbackInfo(arg2,arg3);
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 resultobj = SWIG_Py_Void();
19395 return resultobj;
19396 fail:
19397 return NULL;
19398 }
19399
19400
19401 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19402 PyObject *resultobj = 0;
19403 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19404 int res1 = 0 ;
19405 PyObject * obj0 = 0 ;
19406 char * kwnames[] = {
19407 (char *) "provider", NULL
19408 };
19409
19410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19411 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19412 if (!SWIG_IsOK(res1)) {
19413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19414 }
19415 {
19416 PyThreadState* __tstate = wxPyBeginAllowThreads();
19417 wxPyArtProvider::PushProvider(arg1);
19418 wxPyEndAllowThreads(__tstate);
19419 if (PyErr_Occurred()) SWIG_fail;
19420 }
19421 resultobj = SWIG_Py_Void();
19422 return resultobj;
19423 fail:
19424 return NULL;
19425 }
19426
19427
19428 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19429 PyObject *resultobj = 0;
19430 bool result;
19431
19432 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 result = (bool)wxPyArtProvider::PopProvider();
19436 wxPyEndAllowThreads(__tstate);
19437 if (PyErr_Occurred()) SWIG_fail;
19438 }
19439 {
19440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19441 }
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19449 PyObject *resultobj = 0;
19450 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19451 bool result;
19452 void *argp1 = 0 ;
19453 int res1 = 0 ;
19454 PyObject * obj0 = 0 ;
19455 char * kwnames[] = {
19456 (char *) "provider", NULL
19457 };
19458
19459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19461 if (!SWIG_IsOK(res1)) {
19462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19463 }
19464 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19465 {
19466 PyThreadState* __tstate = wxPyBeginAllowThreads();
19467 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19468 wxPyEndAllowThreads(__tstate);
19469 if (PyErr_Occurred()) SWIG_fail;
19470 }
19471 {
19472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19473 }
19474 return resultobj;
19475 fail:
19476 return NULL;
19477 }
19478
19479
19480 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19481 PyObject *resultobj = 0;
19482 wxString *arg1 = 0 ;
19483 wxString const &arg2_defvalue = wxPyART_OTHER ;
19484 wxString *arg2 = (wxString *) &arg2_defvalue ;
19485 wxSize const &arg3_defvalue = wxDefaultSize ;
19486 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19487 wxBitmap result;
19488 bool temp1 = false ;
19489 bool temp2 = false ;
19490 wxSize temp3 ;
19491 PyObject * obj0 = 0 ;
19492 PyObject * obj1 = 0 ;
19493 PyObject * obj2 = 0 ;
19494 char * kwnames[] = {
19495 (char *) "id",(char *) "client",(char *) "size", NULL
19496 };
19497
19498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19499 {
19500 arg1 = wxString_in_helper(obj0);
19501 if (arg1 == NULL) SWIG_fail;
19502 temp1 = true;
19503 }
19504 if (obj1) {
19505 {
19506 arg2 = wxString_in_helper(obj1);
19507 if (arg2 == NULL) SWIG_fail;
19508 temp2 = true;
19509 }
19510 }
19511 if (obj2) {
19512 {
19513 arg3 = &temp3;
19514 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19515 }
19516 }
19517 {
19518 if (!wxPyCheckForApp()) SWIG_fail;
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19521 wxPyEndAllowThreads(__tstate);
19522 if (PyErr_Occurred()) SWIG_fail;
19523 }
19524 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19525 {
19526 if (temp1)
19527 delete arg1;
19528 }
19529 {
19530 if (temp2)
19531 delete arg2;
19532 }
19533 return resultobj;
19534 fail:
19535 {
19536 if (temp1)
19537 delete arg1;
19538 }
19539 {
19540 if (temp2)
19541 delete arg2;
19542 }
19543 return NULL;
19544 }
19545
19546
19547 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19548 PyObject *resultobj = 0;
19549 wxString *arg1 = 0 ;
19550 wxString const &arg2_defvalue = wxPyART_OTHER ;
19551 wxString *arg2 = (wxString *) &arg2_defvalue ;
19552 wxSize const &arg3_defvalue = wxDefaultSize ;
19553 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19554 wxIcon result;
19555 bool temp1 = false ;
19556 bool temp2 = false ;
19557 wxSize temp3 ;
19558 PyObject * obj0 = 0 ;
19559 PyObject * obj1 = 0 ;
19560 PyObject * obj2 = 0 ;
19561 char * kwnames[] = {
19562 (char *) "id",(char *) "client",(char *) "size", NULL
19563 };
19564
19565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19566 {
19567 arg1 = wxString_in_helper(obj0);
19568 if (arg1 == NULL) SWIG_fail;
19569 temp1 = true;
19570 }
19571 if (obj1) {
19572 {
19573 arg2 = wxString_in_helper(obj1);
19574 if (arg2 == NULL) SWIG_fail;
19575 temp2 = true;
19576 }
19577 }
19578 if (obj2) {
19579 {
19580 arg3 = &temp3;
19581 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19582 }
19583 }
19584 {
19585 if (!wxPyCheckForApp()) SWIG_fail;
19586 PyThreadState* __tstate = wxPyBeginAllowThreads();
19587 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19588 wxPyEndAllowThreads(__tstate);
19589 if (PyErr_Occurred()) SWIG_fail;
19590 }
19591 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19592 {
19593 if (temp1)
19594 delete arg1;
19595 }
19596 {
19597 if (temp2)
19598 delete arg2;
19599 }
19600 return resultobj;
19601 fail:
19602 {
19603 if (temp1)
19604 delete arg1;
19605 }
19606 {
19607 if (temp2)
19608 delete arg2;
19609 }
19610 return NULL;
19611 }
19612
19613
19614 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19615 PyObject *resultobj = 0;
19616 wxString *arg1 = 0 ;
19617 bool arg2 = (bool) false ;
19618 wxSize result;
19619 bool temp1 = false ;
19620 bool val2 ;
19621 int ecode2 = 0 ;
19622 PyObject * obj0 = 0 ;
19623 PyObject * obj1 = 0 ;
19624 char * kwnames[] = {
19625 (char *) "client",(char *) "platform_dependent", NULL
19626 };
19627
19628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19629 {
19630 arg1 = wxString_in_helper(obj0);
19631 if (arg1 == NULL) SWIG_fail;
19632 temp1 = true;
19633 }
19634 if (obj1) {
19635 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19636 if (!SWIG_IsOK(ecode2)) {
19637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19638 }
19639 arg2 = static_cast< bool >(val2);
19640 }
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19644 wxPyEndAllowThreads(__tstate);
19645 if (PyErr_Occurred()) SWIG_fail;
19646 }
19647 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19648 {
19649 if (temp1)
19650 delete arg1;
19651 }
19652 return resultobj;
19653 fail:
19654 {
19655 if (temp1)
19656 delete arg1;
19657 }
19658 return NULL;
19659 }
19660
19661
19662 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19663 PyObject *resultobj = 0;
19664 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19665 void *argp1 = 0 ;
19666 int res1 = 0 ;
19667 PyObject *swig_obj[1] ;
19668
19669 if (!args) SWIG_fail;
19670 swig_obj[0] = args;
19671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19672 if (!SWIG_IsOK(res1)) {
19673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19674 }
19675 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 wxPyArtProvider_Destroy(arg1);
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 resultobj = SWIG_Py_Void();
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19690 PyObject *obj;
19691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19692 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19693 return SWIG_Py_Void();
19694 }
19695
19696 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19697 return SWIG_Python_InitShadowInstance(args);
19698 }
19699
19700 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19701 PyObject *resultobj = 0;
19702 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19703 void *argp1 = 0 ;
19704 int res1 = 0 ;
19705 PyObject *swig_obj[1] ;
19706
19707 if (!args) SWIG_fail;
19708 swig_obj[0] = args;
19709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19710 if (!SWIG_IsOK(res1)) {
19711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19712 }
19713 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 delete arg1;
19717
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_Py_Void();
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19729 PyObject *resultobj = 0;
19730 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19731 wxConfigBase *result = 0 ;
19732 int res1 = 0 ;
19733 PyObject * obj0 = 0 ;
19734 char * kwnames[] = {
19735 (char *) "config", NULL
19736 };
19737
19738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19739 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19740 if (!SWIG_IsOK(res1)) {
19741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19742 }
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj = 0;
19758 bool arg1 = (bool) true ;
19759 wxConfigBase *result = 0 ;
19760 bool val1 ;
19761 int ecode1 = 0 ;
19762 PyObject * obj0 = 0 ;
19763 char * kwnames[] = {
19764 (char *) "createOnDemand", NULL
19765 };
19766
19767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19768 if (obj0) {
19769 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19770 if (!SWIG_IsOK(ecode1)) {
19771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19772 }
19773 arg1 = static_cast< bool >(val1);
19774 }
19775 {
19776 PyThreadState* __tstate = wxPyBeginAllowThreads();
19777 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19778 wxPyEndAllowThreads(__tstate);
19779 if (PyErr_Occurred()) SWIG_fail;
19780 }
19781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19782 return resultobj;
19783 fail:
19784 return NULL;
19785 }
19786
19787
19788 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19789 PyObject *resultobj = 0;
19790 wxConfigBase *result = 0 ;
19791
19792 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 result = (wxConfigBase *)wxConfigBase::Create();
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19807 PyObject *resultobj = 0;
19808
19809 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19810 {
19811 PyThreadState* __tstate = wxPyBeginAllowThreads();
19812 wxConfigBase::DontCreateOnDemand();
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 resultobj = SWIG_Py_Void();
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = 0;
19825 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19826 wxString *arg2 = 0 ;
19827 void *argp1 = 0 ;
19828 int res1 = 0 ;
19829 bool temp2 = false ;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 char * kwnames[] = {
19833 (char *) "self",(char *) "path", NULL
19834 };
19835
19836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19838 if (!SWIG_IsOK(res1)) {
19839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19840 }
19841 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19842 {
19843 arg2 = wxString_in_helper(obj1);
19844 if (arg2 == NULL) SWIG_fail;
19845 temp2 = true;
19846 }
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 (arg1)->SetPath((wxString const &)*arg2);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_Py_Void();
19854 {
19855 if (temp2)
19856 delete arg2;
19857 }
19858 return resultobj;
19859 fail:
19860 {
19861 if (temp2)
19862 delete arg2;
19863 }
19864 return NULL;
19865 }
19866
19867
19868 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19869 PyObject *resultobj = 0;
19870 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19871 wxString *result = 0 ;
19872 void *argp1 = 0 ;
19873 int res1 = 0 ;
19874 PyObject *swig_obj[1] ;
19875
19876 if (!args) SWIG_fail;
19877 swig_obj[0] = args;
19878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19879 if (!SWIG_IsOK(res1)) {
19880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19881 }
19882 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19883 {
19884 PyThreadState* __tstate = wxPyBeginAllowThreads();
19885 {
19886 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19887 result = (wxString *) &_result_ref;
19888 }
19889 wxPyEndAllowThreads(__tstate);
19890 if (PyErr_Occurred()) SWIG_fail;
19891 }
19892 {
19893 #if wxUSE_UNICODE
19894 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19895 #else
19896 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19897 #endif
19898 }
19899 return resultobj;
19900 fail:
19901 return NULL;
19902 }
19903
19904
19905 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19906 PyObject *resultobj = 0;
19907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19908 PyObject *result = 0 ;
19909 void *argp1 = 0 ;
19910 int res1 = 0 ;
19911 PyObject *swig_obj[1] ;
19912
19913 if (!args) SWIG_fail;
19914 swig_obj[0] = args;
19915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19916 if (!SWIG_IsOK(res1)) {
19917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19918 }
19919 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 resultobj = result;
19927 return resultobj;
19928 fail:
19929 return NULL;
19930 }
19931
19932
19933 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19934 PyObject *resultobj = 0;
19935 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19936 long arg2 ;
19937 PyObject *result = 0 ;
19938 void *argp1 = 0 ;
19939 int res1 = 0 ;
19940 long val2 ;
19941 int ecode2 = 0 ;
19942 PyObject * obj0 = 0 ;
19943 PyObject * obj1 = 0 ;
19944 char * kwnames[] = {
19945 (char *) "self",(char *) "index", NULL
19946 };
19947
19948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19950 if (!SWIG_IsOK(res1)) {
19951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19952 }
19953 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19954 ecode2 = SWIG_AsVal_long(obj1, &val2);
19955 if (!SWIG_IsOK(ecode2)) {
19956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19957 }
19958 arg2 = static_cast< long >(val2);
19959 {
19960 PyThreadState* __tstate = wxPyBeginAllowThreads();
19961 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19962 wxPyEndAllowThreads(__tstate);
19963 if (PyErr_Occurred()) SWIG_fail;
19964 }
19965 resultobj = result;
19966 return resultobj;
19967 fail:
19968 return NULL;
19969 }
19970
19971
19972 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19973 PyObject *resultobj = 0;
19974 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19975 PyObject *result = 0 ;
19976 void *argp1 = 0 ;
19977 int res1 = 0 ;
19978 PyObject *swig_obj[1] ;
19979
19980 if (!args) SWIG_fail;
19981 swig_obj[0] = args;
19982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19983 if (!SWIG_IsOK(res1)) {
19984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19985 }
19986 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19987 {
19988 PyThreadState* __tstate = wxPyBeginAllowThreads();
19989 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19990 wxPyEndAllowThreads(__tstate);
19991 if (PyErr_Occurred()) SWIG_fail;
19992 }
19993 resultobj = result;
19994 return resultobj;
19995 fail:
19996 return NULL;
19997 }
19998
19999
20000 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20001 PyObject *resultobj = 0;
20002 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20003 long arg2 ;
20004 PyObject *result = 0 ;
20005 void *argp1 = 0 ;
20006 int res1 = 0 ;
20007 long val2 ;
20008 int ecode2 = 0 ;
20009 PyObject * obj0 = 0 ;
20010 PyObject * obj1 = 0 ;
20011 char * kwnames[] = {
20012 (char *) "self",(char *) "index", NULL
20013 };
20014
20015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20017 if (!SWIG_IsOK(res1)) {
20018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20019 }
20020 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20021 ecode2 = SWIG_AsVal_long(obj1, &val2);
20022 if (!SWIG_IsOK(ecode2)) {
20023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20024 }
20025 arg2 = static_cast< long >(val2);
20026 {
20027 PyThreadState* __tstate = wxPyBeginAllowThreads();
20028 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20029 wxPyEndAllowThreads(__tstate);
20030 if (PyErr_Occurred()) SWIG_fail;
20031 }
20032 resultobj = result;
20033 return resultobj;
20034 fail:
20035 return NULL;
20036 }
20037
20038
20039 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20040 PyObject *resultobj = 0;
20041 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20042 bool arg2 = (bool) false ;
20043 size_t result;
20044 void *argp1 = 0 ;
20045 int res1 = 0 ;
20046 bool val2 ;
20047 int ecode2 = 0 ;
20048 PyObject * obj0 = 0 ;
20049 PyObject * obj1 = 0 ;
20050 char * kwnames[] = {
20051 (char *) "self",(char *) "recursive", NULL
20052 };
20053
20054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20056 if (!SWIG_IsOK(res1)) {
20057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20058 }
20059 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20060 if (obj1) {
20061 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20062 if (!SWIG_IsOK(ecode2)) {
20063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20064 }
20065 arg2 = static_cast< bool >(val2);
20066 }
20067 {
20068 PyThreadState* __tstate = wxPyBeginAllowThreads();
20069 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20070 wxPyEndAllowThreads(__tstate);
20071 if (PyErr_Occurred()) SWIG_fail;
20072 }
20073 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20074 return resultobj;
20075 fail:
20076 return NULL;
20077 }
20078
20079
20080 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20081 PyObject *resultobj = 0;
20082 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20083 bool arg2 = (bool) false ;
20084 size_t result;
20085 void *argp1 = 0 ;
20086 int res1 = 0 ;
20087 bool val2 ;
20088 int ecode2 = 0 ;
20089 PyObject * obj0 = 0 ;
20090 PyObject * obj1 = 0 ;
20091 char * kwnames[] = {
20092 (char *) "self",(char *) "recursive", NULL
20093 };
20094
20095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20097 if (!SWIG_IsOK(res1)) {
20098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20099 }
20100 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20101 if (obj1) {
20102 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20103 if (!SWIG_IsOK(ecode2)) {
20104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
20105 }
20106 arg2 = static_cast< bool >(val2);
20107 }
20108 {
20109 PyThreadState* __tstate = wxPyBeginAllowThreads();
20110 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj = 0;
20123 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20124 wxString *arg2 = 0 ;
20125 bool result;
20126 void *argp1 = 0 ;
20127 int res1 = 0 ;
20128 bool temp2 = false ;
20129 PyObject * obj0 = 0 ;
20130 PyObject * obj1 = 0 ;
20131 char * kwnames[] = {
20132 (char *) "self",(char *) "name", NULL
20133 };
20134
20135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20137 if (!SWIG_IsOK(res1)) {
20138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20139 }
20140 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20141 {
20142 arg2 = wxString_in_helper(obj1);
20143 if (arg2 == NULL) SWIG_fail;
20144 temp2 = true;
20145 }
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 {
20153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20154 }
20155 {
20156 if (temp2)
20157 delete arg2;
20158 }
20159 return resultobj;
20160 fail:
20161 {
20162 if (temp2)
20163 delete arg2;
20164 }
20165 return NULL;
20166 }
20167
20168
20169 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20170 PyObject *resultobj = 0;
20171 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20172 wxString *arg2 = 0 ;
20173 bool result;
20174 void *argp1 = 0 ;
20175 int res1 = 0 ;
20176 bool temp2 = false ;
20177 PyObject * obj0 = 0 ;
20178 PyObject * obj1 = 0 ;
20179 char * kwnames[] = {
20180 (char *) "self",(char *) "name", NULL
20181 };
20182
20183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20185 if (!SWIG_IsOK(res1)) {
20186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20187 }
20188 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20189 {
20190 arg2 = wxString_in_helper(obj1);
20191 if (arg2 == NULL) SWIG_fail;
20192 temp2 = true;
20193 }
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 {
20201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20202 }
20203 {
20204 if (temp2)
20205 delete arg2;
20206 }
20207 return resultobj;
20208 fail:
20209 {
20210 if (temp2)
20211 delete arg2;
20212 }
20213 return NULL;
20214 }
20215
20216
20217 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj = 0;
20219 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20220 wxString *arg2 = 0 ;
20221 bool result;
20222 void *argp1 = 0 ;
20223 int res1 = 0 ;
20224 bool temp2 = false ;
20225 PyObject * obj0 = 0 ;
20226 PyObject * obj1 = 0 ;
20227 char * kwnames[] = {
20228 (char *) "self",(char *) "name", NULL
20229 };
20230
20231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20233 if (!SWIG_IsOK(res1)) {
20234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20235 }
20236 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20237 {
20238 arg2 = wxString_in_helper(obj1);
20239 if (arg2 == NULL) SWIG_fail;
20240 temp2 = true;
20241 }
20242 {
20243 PyThreadState* __tstate = wxPyBeginAllowThreads();
20244 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20245 wxPyEndAllowThreads(__tstate);
20246 if (PyErr_Occurred()) SWIG_fail;
20247 }
20248 {
20249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20250 }
20251 {
20252 if (temp2)
20253 delete arg2;
20254 }
20255 return resultobj;
20256 fail:
20257 {
20258 if (temp2)
20259 delete arg2;
20260 }
20261 return NULL;
20262 }
20263
20264
20265 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20266 PyObject *resultobj = 0;
20267 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20268 wxString *arg2 = 0 ;
20269 wxConfigBase::EntryType result;
20270 void *argp1 = 0 ;
20271 int res1 = 0 ;
20272 bool temp2 = false ;
20273 PyObject * obj0 = 0 ;
20274 PyObject * obj1 = 0 ;
20275 char * kwnames[] = {
20276 (char *) "self",(char *) "name", NULL
20277 };
20278
20279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20281 if (!SWIG_IsOK(res1)) {
20282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20283 }
20284 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20285 {
20286 arg2 = wxString_in_helper(obj1);
20287 if (arg2 == NULL) SWIG_fail;
20288 temp2 = true;
20289 }
20290 {
20291 PyThreadState* __tstate = wxPyBeginAllowThreads();
20292 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 resultobj = SWIG_From_int(static_cast< int >(result));
20297 {
20298 if (temp2)
20299 delete arg2;
20300 }
20301 return resultobj;
20302 fail:
20303 {
20304 if (temp2)
20305 delete arg2;
20306 }
20307 return NULL;
20308 }
20309
20310
20311 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20312 PyObject *resultobj = 0;
20313 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20314 wxString *arg2 = 0 ;
20315 wxString const &arg3_defvalue = wxPyEmptyString ;
20316 wxString *arg3 = (wxString *) &arg3_defvalue ;
20317 wxString result;
20318 void *argp1 = 0 ;
20319 int res1 = 0 ;
20320 bool temp2 = false ;
20321 bool temp3 = false ;
20322 PyObject * obj0 = 0 ;
20323 PyObject * obj1 = 0 ;
20324 PyObject * obj2 = 0 ;
20325 char * kwnames[] = {
20326 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20327 };
20328
20329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20331 if (!SWIG_IsOK(res1)) {
20332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20333 }
20334 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20335 {
20336 arg2 = wxString_in_helper(obj1);
20337 if (arg2 == NULL) SWIG_fail;
20338 temp2 = true;
20339 }
20340 if (obj2) {
20341 {
20342 arg3 = wxString_in_helper(obj2);
20343 if (arg3 == NULL) SWIG_fail;
20344 temp3 = true;
20345 }
20346 }
20347 {
20348 PyThreadState* __tstate = wxPyBeginAllowThreads();
20349 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20350 wxPyEndAllowThreads(__tstate);
20351 if (PyErr_Occurred()) SWIG_fail;
20352 }
20353 {
20354 #if wxUSE_UNICODE
20355 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20356 #else
20357 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20358 #endif
20359 }
20360 {
20361 if (temp2)
20362 delete arg2;
20363 }
20364 {
20365 if (temp3)
20366 delete arg3;
20367 }
20368 return resultobj;
20369 fail:
20370 {
20371 if (temp2)
20372 delete arg2;
20373 }
20374 {
20375 if (temp3)
20376 delete arg3;
20377 }
20378 return NULL;
20379 }
20380
20381
20382 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20383 PyObject *resultobj = 0;
20384 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20385 wxString *arg2 = 0 ;
20386 long arg3 = (long) 0 ;
20387 long result;
20388 void *argp1 = 0 ;
20389 int res1 = 0 ;
20390 bool temp2 = false ;
20391 long val3 ;
20392 int ecode3 = 0 ;
20393 PyObject * obj0 = 0 ;
20394 PyObject * obj1 = 0 ;
20395 PyObject * obj2 = 0 ;
20396 char * kwnames[] = {
20397 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20398 };
20399
20400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20402 if (!SWIG_IsOK(res1)) {
20403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20404 }
20405 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20406 {
20407 arg2 = wxString_in_helper(obj1);
20408 if (arg2 == NULL) SWIG_fail;
20409 temp2 = true;
20410 }
20411 if (obj2) {
20412 ecode3 = SWIG_AsVal_long(obj2, &val3);
20413 if (!SWIG_IsOK(ecode3)) {
20414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20415 }
20416 arg3 = static_cast< long >(val3);
20417 }
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20421 wxPyEndAllowThreads(__tstate);
20422 if (PyErr_Occurred()) SWIG_fail;
20423 }
20424 resultobj = SWIG_From_long(static_cast< long >(result));
20425 {
20426 if (temp2)
20427 delete arg2;
20428 }
20429 return resultobj;
20430 fail:
20431 {
20432 if (temp2)
20433 delete arg2;
20434 }
20435 return NULL;
20436 }
20437
20438
20439 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20440 PyObject *resultobj = 0;
20441 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20442 wxString *arg2 = 0 ;
20443 double arg3 = (double) 0.0 ;
20444 double result;
20445 void *argp1 = 0 ;
20446 int res1 = 0 ;
20447 bool temp2 = false ;
20448 double val3 ;
20449 int ecode3 = 0 ;
20450 PyObject * obj0 = 0 ;
20451 PyObject * obj1 = 0 ;
20452 PyObject * obj2 = 0 ;
20453 char * kwnames[] = {
20454 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20455 };
20456
20457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20459 if (!SWIG_IsOK(res1)) {
20460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20461 }
20462 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20463 {
20464 arg2 = wxString_in_helper(obj1);
20465 if (arg2 == NULL) SWIG_fail;
20466 temp2 = true;
20467 }
20468 if (obj2) {
20469 ecode3 = SWIG_AsVal_double(obj2, &val3);
20470 if (!SWIG_IsOK(ecode3)) {
20471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20472 }
20473 arg3 = static_cast< double >(val3);
20474 }
20475 {
20476 PyThreadState* __tstate = wxPyBeginAllowThreads();
20477 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20478 wxPyEndAllowThreads(__tstate);
20479 if (PyErr_Occurred()) SWIG_fail;
20480 }
20481 resultobj = SWIG_From_double(static_cast< double >(result));
20482 {
20483 if (temp2)
20484 delete arg2;
20485 }
20486 return resultobj;
20487 fail:
20488 {
20489 if (temp2)
20490 delete arg2;
20491 }
20492 return NULL;
20493 }
20494
20495
20496 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20497 PyObject *resultobj = 0;
20498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20499 wxString *arg2 = 0 ;
20500 bool arg3 = (bool) false ;
20501 bool result;
20502 void *argp1 = 0 ;
20503 int res1 = 0 ;
20504 bool temp2 = false ;
20505 bool val3 ;
20506 int ecode3 = 0 ;
20507 PyObject * obj0 = 0 ;
20508 PyObject * obj1 = 0 ;
20509 PyObject * obj2 = 0 ;
20510 char * kwnames[] = {
20511 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20512 };
20513
20514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20516 if (!SWIG_IsOK(res1)) {
20517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20518 }
20519 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20520 {
20521 arg2 = wxString_in_helper(obj1);
20522 if (arg2 == NULL) SWIG_fail;
20523 temp2 = true;
20524 }
20525 if (obj2) {
20526 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20527 if (!SWIG_IsOK(ecode3)) {
20528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20529 }
20530 arg3 = static_cast< bool >(val3);
20531 }
20532 {
20533 PyThreadState* __tstate = wxPyBeginAllowThreads();
20534 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 {
20539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20540 }
20541 {
20542 if (temp2)
20543 delete arg2;
20544 }
20545 return resultobj;
20546 fail:
20547 {
20548 if (temp2)
20549 delete arg2;
20550 }
20551 return NULL;
20552 }
20553
20554
20555 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20556 PyObject *resultobj = 0;
20557 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20558 wxString *arg2 = 0 ;
20559 wxString *arg3 = 0 ;
20560 bool result;
20561 void *argp1 = 0 ;
20562 int res1 = 0 ;
20563 bool temp2 = false ;
20564 bool temp3 = false ;
20565 PyObject * obj0 = 0 ;
20566 PyObject * obj1 = 0 ;
20567 PyObject * obj2 = 0 ;
20568 char * kwnames[] = {
20569 (char *) "self",(char *) "key",(char *) "value", NULL
20570 };
20571
20572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20574 if (!SWIG_IsOK(res1)) {
20575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20576 }
20577 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20578 {
20579 arg2 = wxString_in_helper(obj1);
20580 if (arg2 == NULL) SWIG_fail;
20581 temp2 = true;
20582 }
20583 {
20584 arg3 = wxString_in_helper(obj2);
20585 if (arg3 == NULL) SWIG_fail;
20586 temp3 = true;
20587 }
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20591 wxPyEndAllowThreads(__tstate);
20592 if (PyErr_Occurred()) SWIG_fail;
20593 }
20594 {
20595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20596 }
20597 {
20598 if (temp2)
20599 delete arg2;
20600 }
20601 {
20602 if (temp3)
20603 delete arg3;
20604 }
20605 return resultobj;
20606 fail:
20607 {
20608 if (temp2)
20609 delete arg2;
20610 }
20611 {
20612 if (temp3)
20613 delete arg3;
20614 }
20615 return NULL;
20616 }
20617
20618
20619 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20620 PyObject *resultobj = 0;
20621 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20622 wxString *arg2 = 0 ;
20623 long arg3 ;
20624 bool result;
20625 void *argp1 = 0 ;
20626 int res1 = 0 ;
20627 bool temp2 = false ;
20628 long val3 ;
20629 int ecode3 = 0 ;
20630 PyObject * obj0 = 0 ;
20631 PyObject * obj1 = 0 ;
20632 PyObject * obj2 = 0 ;
20633 char * kwnames[] = {
20634 (char *) "self",(char *) "key",(char *) "value", NULL
20635 };
20636
20637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20639 if (!SWIG_IsOK(res1)) {
20640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20641 }
20642 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20643 {
20644 arg2 = wxString_in_helper(obj1);
20645 if (arg2 == NULL) SWIG_fail;
20646 temp2 = true;
20647 }
20648 ecode3 = SWIG_AsVal_long(obj2, &val3);
20649 if (!SWIG_IsOK(ecode3)) {
20650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20651 }
20652 arg3 = static_cast< long >(val3);
20653 {
20654 PyThreadState* __tstate = wxPyBeginAllowThreads();
20655 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20656 wxPyEndAllowThreads(__tstate);
20657 if (PyErr_Occurred()) SWIG_fail;
20658 }
20659 {
20660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20661 }
20662 {
20663 if (temp2)
20664 delete arg2;
20665 }
20666 return resultobj;
20667 fail:
20668 {
20669 if (temp2)
20670 delete arg2;
20671 }
20672 return NULL;
20673 }
20674
20675
20676 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20677 PyObject *resultobj = 0;
20678 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20679 wxString *arg2 = 0 ;
20680 double arg3 ;
20681 bool result;
20682 void *argp1 = 0 ;
20683 int res1 = 0 ;
20684 bool temp2 = false ;
20685 double val3 ;
20686 int ecode3 = 0 ;
20687 PyObject * obj0 = 0 ;
20688 PyObject * obj1 = 0 ;
20689 PyObject * obj2 = 0 ;
20690 char * kwnames[] = {
20691 (char *) "self",(char *) "key",(char *) "value", NULL
20692 };
20693
20694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20696 if (!SWIG_IsOK(res1)) {
20697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20698 }
20699 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20700 {
20701 arg2 = wxString_in_helper(obj1);
20702 if (arg2 == NULL) SWIG_fail;
20703 temp2 = true;
20704 }
20705 ecode3 = SWIG_AsVal_double(obj2, &val3);
20706 if (!SWIG_IsOK(ecode3)) {
20707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20708 }
20709 arg3 = static_cast< double >(val3);
20710 {
20711 PyThreadState* __tstate = wxPyBeginAllowThreads();
20712 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 {
20717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20718 }
20719 {
20720 if (temp2)
20721 delete arg2;
20722 }
20723 return resultobj;
20724 fail:
20725 {
20726 if (temp2)
20727 delete arg2;
20728 }
20729 return NULL;
20730 }
20731
20732
20733 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20734 PyObject *resultobj = 0;
20735 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20736 wxString *arg2 = 0 ;
20737 bool arg3 ;
20738 bool result;
20739 void *argp1 = 0 ;
20740 int res1 = 0 ;
20741 bool temp2 = false ;
20742 bool val3 ;
20743 int ecode3 = 0 ;
20744 PyObject * obj0 = 0 ;
20745 PyObject * obj1 = 0 ;
20746 PyObject * obj2 = 0 ;
20747 char * kwnames[] = {
20748 (char *) "self",(char *) "key",(char *) "value", NULL
20749 };
20750
20751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20753 if (!SWIG_IsOK(res1)) {
20754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20755 }
20756 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20757 {
20758 arg2 = wxString_in_helper(obj1);
20759 if (arg2 == NULL) SWIG_fail;
20760 temp2 = true;
20761 }
20762 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20763 if (!SWIG_IsOK(ecode3)) {
20764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20765 }
20766 arg3 = static_cast< bool >(val3);
20767 {
20768 PyThreadState* __tstate = wxPyBeginAllowThreads();
20769 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20770 wxPyEndAllowThreads(__tstate);
20771 if (PyErr_Occurred()) SWIG_fail;
20772 }
20773 {
20774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20775 }
20776 {
20777 if (temp2)
20778 delete arg2;
20779 }
20780 return resultobj;
20781 fail:
20782 {
20783 if (temp2)
20784 delete arg2;
20785 }
20786 return NULL;
20787 }
20788
20789
20790 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20791 PyObject *resultobj = 0;
20792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20793 bool arg2 = (bool) false ;
20794 bool result;
20795 void *argp1 = 0 ;
20796 int res1 = 0 ;
20797 bool val2 ;
20798 int ecode2 = 0 ;
20799 PyObject * obj0 = 0 ;
20800 PyObject * obj1 = 0 ;
20801 char * kwnames[] = {
20802 (char *) "self",(char *) "currentOnly", NULL
20803 };
20804
20805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20807 if (!SWIG_IsOK(res1)) {
20808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20809 }
20810 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20811 if (obj1) {
20812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20813 if (!SWIG_IsOK(ecode2)) {
20814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20815 }
20816 arg2 = static_cast< bool >(val2);
20817 }
20818 {
20819 PyThreadState* __tstate = wxPyBeginAllowThreads();
20820 result = (bool)(arg1)->Flush(arg2);
20821 wxPyEndAllowThreads(__tstate);
20822 if (PyErr_Occurred()) SWIG_fail;
20823 }
20824 {
20825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20826 }
20827 return resultobj;
20828 fail:
20829 return NULL;
20830 }
20831
20832
20833 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20834 PyObject *resultobj = 0;
20835 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20836 wxString *arg2 = 0 ;
20837 wxString *arg3 = 0 ;
20838 bool result;
20839 void *argp1 = 0 ;
20840 int res1 = 0 ;
20841 bool temp2 = false ;
20842 bool temp3 = false ;
20843 PyObject * obj0 = 0 ;
20844 PyObject * obj1 = 0 ;
20845 PyObject * obj2 = 0 ;
20846 char * kwnames[] = {
20847 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20848 };
20849
20850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20852 if (!SWIG_IsOK(res1)) {
20853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20854 }
20855 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20856 {
20857 arg2 = wxString_in_helper(obj1);
20858 if (arg2 == NULL) SWIG_fail;
20859 temp2 = true;
20860 }
20861 {
20862 arg3 = wxString_in_helper(obj2);
20863 if (arg3 == NULL) SWIG_fail;
20864 temp3 = true;
20865 }
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20869 wxPyEndAllowThreads(__tstate);
20870 if (PyErr_Occurred()) SWIG_fail;
20871 }
20872 {
20873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20874 }
20875 {
20876 if (temp2)
20877 delete arg2;
20878 }
20879 {
20880 if (temp3)
20881 delete arg3;
20882 }
20883 return resultobj;
20884 fail:
20885 {
20886 if (temp2)
20887 delete arg2;
20888 }
20889 {
20890 if (temp3)
20891 delete arg3;
20892 }
20893 return NULL;
20894 }
20895
20896
20897 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj = 0;
20899 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20900 wxString *arg2 = 0 ;
20901 wxString *arg3 = 0 ;
20902 bool result;
20903 void *argp1 = 0 ;
20904 int res1 = 0 ;
20905 bool temp2 = false ;
20906 bool temp3 = false ;
20907 PyObject * obj0 = 0 ;
20908 PyObject * obj1 = 0 ;
20909 PyObject * obj2 = 0 ;
20910 char * kwnames[] = {
20911 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20912 };
20913
20914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20916 if (!SWIG_IsOK(res1)) {
20917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20918 }
20919 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20920 {
20921 arg2 = wxString_in_helper(obj1);
20922 if (arg2 == NULL) SWIG_fail;
20923 temp2 = true;
20924 }
20925 {
20926 arg3 = wxString_in_helper(obj2);
20927 if (arg3 == NULL) SWIG_fail;
20928 temp3 = true;
20929 }
20930 {
20931 PyThreadState* __tstate = wxPyBeginAllowThreads();
20932 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20933 wxPyEndAllowThreads(__tstate);
20934 if (PyErr_Occurred()) SWIG_fail;
20935 }
20936 {
20937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20938 }
20939 {
20940 if (temp2)
20941 delete arg2;
20942 }
20943 {
20944 if (temp3)
20945 delete arg3;
20946 }
20947 return resultobj;
20948 fail:
20949 {
20950 if (temp2)
20951 delete arg2;
20952 }
20953 {
20954 if (temp3)
20955 delete arg3;
20956 }
20957 return NULL;
20958 }
20959
20960
20961 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20962 PyObject *resultobj = 0;
20963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20964 wxString *arg2 = 0 ;
20965 bool arg3 = (bool) true ;
20966 bool result;
20967 void *argp1 = 0 ;
20968 int res1 = 0 ;
20969 bool temp2 = false ;
20970 bool val3 ;
20971 int ecode3 = 0 ;
20972 PyObject * obj0 = 0 ;
20973 PyObject * obj1 = 0 ;
20974 PyObject * obj2 = 0 ;
20975 char * kwnames[] = {
20976 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20977 };
20978
20979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20981 if (!SWIG_IsOK(res1)) {
20982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20983 }
20984 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20985 {
20986 arg2 = wxString_in_helper(obj1);
20987 if (arg2 == NULL) SWIG_fail;
20988 temp2 = true;
20989 }
20990 if (obj2) {
20991 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20992 if (!SWIG_IsOK(ecode3)) {
20993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20994 }
20995 arg3 = static_cast< bool >(val3);
20996 }
20997 {
20998 PyThreadState* __tstate = wxPyBeginAllowThreads();
20999 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21000 wxPyEndAllowThreads(__tstate);
21001 if (PyErr_Occurred()) SWIG_fail;
21002 }
21003 {
21004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21005 }
21006 {
21007 if (temp2)
21008 delete arg2;
21009 }
21010 return resultobj;
21011 fail:
21012 {
21013 if (temp2)
21014 delete arg2;
21015 }
21016 return NULL;
21017 }
21018
21019
21020 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21021 PyObject *resultobj = 0;
21022 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21023 wxString *arg2 = 0 ;
21024 bool result;
21025 void *argp1 = 0 ;
21026 int res1 = 0 ;
21027 bool temp2 = false ;
21028 PyObject * obj0 = 0 ;
21029 PyObject * obj1 = 0 ;
21030 char * kwnames[] = {
21031 (char *) "self",(char *) "key", NULL
21032 };
21033
21034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21036 if (!SWIG_IsOK(res1)) {
21037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21038 }
21039 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21040 {
21041 arg2 = wxString_in_helper(obj1);
21042 if (arg2 == NULL) SWIG_fail;
21043 temp2 = true;
21044 }
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21048 wxPyEndAllowThreads(__tstate);
21049 if (PyErr_Occurred()) SWIG_fail;
21050 }
21051 {
21052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21053 }
21054 {
21055 if (temp2)
21056 delete arg2;
21057 }
21058 return resultobj;
21059 fail:
21060 {
21061 if (temp2)
21062 delete arg2;
21063 }
21064 return NULL;
21065 }
21066
21067
21068 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21069 PyObject *resultobj = 0;
21070 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21071 bool result;
21072 void *argp1 = 0 ;
21073 int res1 = 0 ;
21074 PyObject *swig_obj[1] ;
21075
21076 if (!args) SWIG_fail;
21077 swig_obj[0] = args;
21078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21079 if (!SWIG_IsOK(res1)) {
21080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21081 }
21082 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21083 {
21084 PyThreadState* __tstate = wxPyBeginAllowThreads();
21085 result = (bool)(arg1)->DeleteAll();
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 {
21090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21091 }
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21099 PyObject *resultobj = 0;
21100 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21101 bool arg2 = (bool) true ;
21102 void *argp1 = 0 ;
21103 int res1 = 0 ;
21104 bool val2 ;
21105 int ecode2 = 0 ;
21106 PyObject * obj0 = 0 ;
21107 PyObject * obj1 = 0 ;
21108 char * kwnames[] = {
21109 (char *) "self",(char *) "doIt", NULL
21110 };
21111
21112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21116 }
21117 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21118 if (obj1) {
21119 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21120 if (!SWIG_IsOK(ecode2)) {
21121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
21122 }
21123 arg2 = static_cast< bool >(val2);
21124 }
21125 {
21126 PyThreadState* __tstate = wxPyBeginAllowThreads();
21127 (arg1)->SetExpandEnvVars(arg2);
21128 wxPyEndAllowThreads(__tstate);
21129 if (PyErr_Occurred()) SWIG_fail;
21130 }
21131 resultobj = SWIG_Py_Void();
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21139 PyObject *resultobj = 0;
21140 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21141 bool result;
21142 void *argp1 = 0 ;
21143 int res1 = 0 ;
21144 PyObject *swig_obj[1] ;
21145
21146 if (!args) SWIG_fail;
21147 swig_obj[0] = args;
21148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21149 if (!SWIG_IsOK(res1)) {
21150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21151 }
21152 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21153 {
21154 PyThreadState* __tstate = wxPyBeginAllowThreads();
21155 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
21156 wxPyEndAllowThreads(__tstate);
21157 if (PyErr_Occurred()) SWIG_fail;
21158 }
21159 {
21160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21161 }
21162 return resultobj;
21163 fail:
21164 return NULL;
21165 }
21166
21167
21168 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21169 PyObject *resultobj = 0;
21170 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21171 bool arg2 = (bool) true ;
21172 void *argp1 = 0 ;
21173 int res1 = 0 ;
21174 bool val2 ;
21175 int ecode2 = 0 ;
21176 PyObject * obj0 = 0 ;
21177 PyObject * obj1 = 0 ;
21178 char * kwnames[] = {
21179 (char *) "self",(char *) "doIt", NULL
21180 };
21181
21182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21184 if (!SWIG_IsOK(res1)) {
21185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21186 }
21187 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21188 if (obj1) {
21189 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21190 if (!SWIG_IsOK(ecode2)) {
21191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21192 }
21193 arg2 = static_cast< bool >(val2);
21194 }
21195 {
21196 PyThreadState* __tstate = wxPyBeginAllowThreads();
21197 (arg1)->SetRecordDefaults(arg2);
21198 wxPyEndAllowThreads(__tstate);
21199 if (PyErr_Occurred()) SWIG_fail;
21200 }
21201 resultobj = SWIG_Py_Void();
21202 return resultobj;
21203 fail:
21204 return NULL;
21205 }
21206
21207
21208 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21209 PyObject *resultobj = 0;
21210 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21211 bool result;
21212 void *argp1 = 0 ;
21213 int res1 = 0 ;
21214 PyObject *swig_obj[1] ;
21215
21216 if (!args) SWIG_fail;
21217 swig_obj[0] = args;
21218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21219 if (!SWIG_IsOK(res1)) {
21220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21221 }
21222 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21223 {
21224 PyThreadState* __tstate = wxPyBeginAllowThreads();
21225 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 {
21230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21231 }
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21239 PyObject *resultobj = 0;
21240 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21241 wxString *arg2 = 0 ;
21242 wxString 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 *) "str", NULL
21250 };
21251
21252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",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_ExpandEnvVars" "', 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 = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21266 wxPyEndAllowThreads(__tstate);
21267 if (PyErr_Occurred()) SWIG_fail;
21268 }
21269 {
21270 #if wxUSE_UNICODE
21271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21272 #else
21273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21274 #endif
21275 }
21276 {
21277 if (temp2)
21278 delete arg2;
21279 }
21280 return resultobj;
21281 fail:
21282 {
21283 if (temp2)
21284 delete arg2;
21285 }
21286 return NULL;
21287 }
21288
21289
21290 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21291 PyObject *resultobj = 0;
21292 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21293 wxString result;
21294 void *argp1 = 0 ;
21295 int res1 = 0 ;
21296 PyObject *swig_obj[1] ;
21297
21298 if (!args) SWIG_fail;
21299 swig_obj[0] = args;
21300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21303 }
21304 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21305 {
21306 PyThreadState* __tstate = wxPyBeginAllowThreads();
21307 result = ((wxConfigBase const *)arg1)->GetAppName();
21308 wxPyEndAllowThreads(__tstate);
21309 if (PyErr_Occurred()) SWIG_fail;
21310 }
21311 {
21312 #if wxUSE_UNICODE
21313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21314 #else
21315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21316 #endif
21317 }
21318 return resultobj;
21319 fail:
21320 return NULL;
21321 }
21322
21323
21324 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21325 PyObject *resultobj = 0;
21326 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21327 wxString result;
21328 void *argp1 = 0 ;
21329 int res1 = 0 ;
21330 PyObject *swig_obj[1] ;
21331
21332 if (!args) SWIG_fail;
21333 swig_obj[0] = args;
21334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21335 if (!SWIG_IsOK(res1)) {
21336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21337 }
21338 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21339 {
21340 PyThreadState* __tstate = wxPyBeginAllowThreads();
21341 result = ((wxConfigBase const *)arg1)->GetVendorName();
21342 wxPyEndAllowThreads(__tstate);
21343 if (PyErr_Occurred()) SWIG_fail;
21344 }
21345 {
21346 #if wxUSE_UNICODE
21347 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21348 #else
21349 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21350 #endif
21351 }
21352 return resultobj;
21353 fail:
21354 return NULL;
21355 }
21356
21357
21358 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21359 PyObject *resultobj = 0;
21360 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21361 wxString *arg2 = 0 ;
21362 void *argp1 = 0 ;
21363 int res1 = 0 ;
21364 bool temp2 = false ;
21365 PyObject * obj0 = 0 ;
21366 PyObject * obj1 = 0 ;
21367 char * kwnames[] = {
21368 (char *) "self",(char *) "appName", NULL
21369 };
21370
21371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21373 if (!SWIG_IsOK(res1)) {
21374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21375 }
21376 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21377 {
21378 arg2 = wxString_in_helper(obj1);
21379 if (arg2 == NULL) SWIG_fail;
21380 temp2 = true;
21381 }
21382 {
21383 PyThreadState* __tstate = wxPyBeginAllowThreads();
21384 (arg1)->SetAppName((wxString const &)*arg2);
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 resultobj = SWIG_Py_Void();
21389 {
21390 if (temp2)
21391 delete arg2;
21392 }
21393 return resultobj;
21394 fail:
21395 {
21396 if (temp2)
21397 delete arg2;
21398 }
21399 return NULL;
21400 }
21401
21402
21403 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21404 PyObject *resultobj = 0;
21405 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21406 wxString *arg2 = 0 ;
21407 void *argp1 = 0 ;
21408 int res1 = 0 ;
21409 bool temp2 = false ;
21410 PyObject * obj0 = 0 ;
21411 PyObject * obj1 = 0 ;
21412 char * kwnames[] = {
21413 (char *) "self",(char *) "vendorName", NULL
21414 };
21415
21416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21418 if (!SWIG_IsOK(res1)) {
21419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21420 }
21421 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21422 {
21423 arg2 = wxString_in_helper(obj1);
21424 if (arg2 == NULL) SWIG_fail;
21425 temp2 = true;
21426 }
21427 {
21428 PyThreadState* __tstate = wxPyBeginAllowThreads();
21429 (arg1)->SetVendorName((wxString const &)*arg2);
21430 wxPyEndAllowThreads(__tstate);
21431 if (PyErr_Occurred()) SWIG_fail;
21432 }
21433 resultobj = SWIG_Py_Void();
21434 {
21435 if (temp2)
21436 delete arg2;
21437 }
21438 return resultobj;
21439 fail:
21440 {
21441 if (temp2)
21442 delete arg2;
21443 }
21444 return NULL;
21445 }
21446
21447
21448 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21449 PyObject *resultobj = 0;
21450 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21451 long arg2 ;
21452 void *argp1 = 0 ;
21453 int res1 = 0 ;
21454 long val2 ;
21455 int ecode2 = 0 ;
21456 PyObject * obj0 = 0 ;
21457 PyObject * obj1 = 0 ;
21458 char * kwnames[] = {
21459 (char *) "self",(char *) "style", NULL
21460 };
21461
21462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21464 if (!SWIG_IsOK(res1)) {
21465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21466 }
21467 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21468 ecode2 = SWIG_AsVal_long(obj1, &val2);
21469 if (!SWIG_IsOK(ecode2)) {
21470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21471 }
21472 arg2 = static_cast< long >(val2);
21473 {
21474 PyThreadState* __tstate = wxPyBeginAllowThreads();
21475 (arg1)->SetStyle(arg2);
21476 wxPyEndAllowThreads(__tstate);
21477 if (PyErr_Occurred()) SWIG_fail;
21478 }
21479 resultobj = SWIG_Py_Void();
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21487 PyObject *resultobj = 0;
21488 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21489 long result;
21490 void *argp1 = 0 ;
21491 int res1 = 0 ;
21492 PyObject *swig_obj[1] ;
21493
21494 if (!args) SWIG_fail;
21495 swig_obj[0] = args;
21496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21497 if (!SWIG_IsOK(res1)) {
21498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21499 }
21500 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21501 {
21502 PyThreadState* __tstate = wxPyBeginAllowThreads();
21503 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21504 wxPyEndAllowThreads(__tstate);
21505 if (PyErr_Occurred()) SWIG_fail;
21506 }
21507 resultobj = SWIG_From_long(static_cast< long >(result));
21508 return resultobj;
21509 fail:
21510 return NULL;
21511 }
21512
21513
21514 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21515 PyObject *obj;
21516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21517 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21518 return SWIG_Py_Void();
21519 }
21520
21521 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21522 PyObject *resultobj = 0;
21523 wxString const &arg1_defvalue = wxPyEmptyString ;
21524 wxString *arg1 = (wxString *) &arg1_defvalue ;
21525 wxString const &arg2_defvalue = wxPyEmptyString ;
21526 wxString *arg2 = (wxString *) &arg2_defvalue ;
21527 wxString const &arg3_defvalue = wxPyEmptyString ;
21528 wxString *arg3 = (wxString *) &arg3_defvalue ;
21529 wxString const &arg4_defvalue = wxPyEmptyString ;
21530 wxString *arg4 = (wxString *) &arg4_defvalue ;
21531 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21532 wxConfig *result = 0 ;
21533 bool temp1 = false ;
21534 bool temp2 = false ;
21535 bool temp3 = false ;
21536 bool temp4 = false ;
21537 long val5 ;
21538 int ecode5 = 0 ;
21539 PyObject * obj0 = 0 ;
21540 PyObject * obj1 = 0 ;
21541 PyObject * obj2 = 0 ;
21542 PyObject * obj3 = 0 ;
21543 PyObject * obj4 = 0 ;
21544 char * kwnames[] = {
21545 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21546 };
21547
21548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21549 if (obj0) {
21550 {
21551 arg1 = wxString_in_helper(obj0);
21552 if (arg1 == NULL) SWIG_fail;
21553 temp1 = true;
21554 }
21555 }
21556 if (obj1) {
21557 {
21558 arg2 = wxString_in_helper(obj1);
21559 if (arg2 == NULL) SWIG_fail;
21560 temp2 = true;
21561 }
21562 }
21563 if (obj2) {
21564 {
21565 arg3 = wxString_in_helper(obj2);
21566 if (arg3 == NULL) SWIG_fail;
21567 temp3 = true;
21568 }
21569 }
21570 if (obj3) {
21571 {
21572 arg4 = wxString_in_helper(obj3);
21573 if (arg4 == NULL) SWIG_fail;
21574 temp4 = true;
21575 }
21576 }
21577 if (obj4) {
21578 ecode5 = SWIG_AsVal_long(obj4, &val5);
21579 if (!SWIG_IsOK(ecode5)) {
21580 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21581 }
21582 arg5 = static_cast< long >(val5);
21583 }
21584 {
21585 PyThreadState* __tstate = wxPyBeginAllowThreads();
21586 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21587 wxPyEndAllowThreads(__tstate);
21588 if (PyErr_Occurred()) SWIG_fail;
21589 }
21590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21591 {
21592 if (temp1)
21593 delete arg1;
21594 }
21595 {
21596 if (temp2)
21597 delete arg2;
21598 }
21599 {
21600 if (temp3)
21601 delete arg3;
21602 }
21603 {
21604 if (temp4)
21605 delete arg4;
21606 }
21607 return resultobj;
21608 fail:
21609 {
21610 if (temp1)
21611 delete arg1;
21612 }
21613 {
21614 if (temp2)
21615 delete arg2;
21616 }
21617 {
21618 if (temp3)
21619 delete arg3;
21620 }
21621 {
21622 if (temp4)
21623 delete arg4;
21624 }
21625 return NULL;
21626 }
21627
21628
21629 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21630 PyObject *resultobj = 0;
21631 wxConfig *arg1 = (wxConfig *) 0 ;
21632 void *argp1 = 0 ;
21633 int res1 = 0 ;
21634 PyObject *swig_obj[1] ;
21635
21636 if (!args) SWIG_fail;
21637 swig_obj[0] = args;
21638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21639 if (!SWIG_IsOK(res1)) {
21640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21641 }
21642 arg1 = reinterpret_cast< wxConfig * >(argp1);
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 delete arg1;
21646
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 resultobj = SWIG_Py_Void();
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21658 PyObject *obj;
21659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21660 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21661 return SWIG_Py_Void();
21662 }
21663
21664 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21665 return SWIG_Python_InitShadowInstance(args);
21666 }
21667
21668 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21669 PyObject *resultobj = 0;
21670 wxString const &arg1_defvalue = wxPyEmptyString ;
21671 wxString *arg1 = (wxString *) &arg1_defvalue ;
21672 wxString const &arg2_defvalue = wxPyEmptyString ;
21673 wxString *arg2 = (wxString *) &arg2_defvalue ;
21674 wxString const &arg3_defvalue = wxPyEmptyString ;
21675 wxString *arg3 = (wxString *) &arg3_defvalue ;
21676 wxString const &arg4_defvalue = wxPyEmptyString ;
21677 wxString *arg4 = (wxString *) &arg4_defvalue ;
21678 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21679 wxFileConfig *result = 0 ;
21680 bool temp1 = false ;
21681 bool temp2 = false ;
21682 bool temp3 = false ;
21683 bool temp4 = false ;
21684 long val5 ;
21685 int ecode5 = 0 ;
21686 PyObject * obj0 = 0 ;
21687 PyObject * obj1 = 0 ;
21688 PyObject * obj2 = 0 ;
21689 PyObject * obj3 = 0 ;
21690 PyObject * obj4 = 0 ;
21691 char * kwnames[] = {
21692 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21693 };
21694
21695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21696 if (obj0) {
21697 {
21698 arg1 = wxString_in_helper(obj0);
21699 if (arg1 == NULL) SWIG_fail;
21700 temp1 = true;
21701 }
21702 }
21703 if (obj1) {
21704 {
21705 arg2 = wxString_in_helper(obj1);
21706 if (arg2 == NULL) SWIG_fail;
21707 temp2 = true;
21708 }
21709 }
21710 if (obj2) {
21711 {
21712 arg3 = wxString_in_helper(obj2);
21713 if (arg3 == NULL) SWIG_fail;
21714 temp3 = true;
21715 }
21716 }
21717 if (obj3) {
21718 {
21719 arg4 = wxString_in_helper(obj3);
21720 if (arg4 == NULL) SWIG_fail;
21721 temp4 = true;
21722 }
21723 }
21724 if (obj4) {
21725 ecode5 = SWIG_AsVal_long(obj4, &val5);
21726 if (!SWIG_IsOK(ecode5)) {
21727 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21728 }
21729 arg5 = static_cast< long >(val5);
21730 }
21731 {
21732 PyThreadState* __tstate = wxPyBeginAllowThreads();
21733 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21734 wxPyEndAllowThreads(__tstate);
21735 if (PyErr_Occurred()) SWIG_fail;
21736 }
21737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21738 {
21739 if (temp1)
21740 delete arg1;
21741 }
21742 {
21743 if (temp2)
21744 delete arg2;
21745 }
21746 {
21747 if (temp3)
21748 delete arg3;
21749 }
21750 {
21751 if (temp4)
21752 delete arg4;
21753 }
21754 return resultobj;
21755 fail:
21756 {
21757 if (temp1)
21758 delete arg1;
21759 }
21760 {
21761 if (temp2)
21762 delete arg2;
21763 }
21764 {
21765 if (temp3)
21766 delete arg3;
21767 }
21768 {
21769 if (temp4)
21770 delete arg4;
21771 }
21772 return NULL;
21773 }
21774
21775
21776 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21777 PyObject *resultobj = 0;
21778 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21779 void *argp1 = 0 ;
21780 int res1 = 0 ;
21781 PyObject *swig_obj[1] ;
21782
21783 if (!args) SWIG_fail;
21784 swig_obj[0] = args;
21785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21786 if (!SWIG_IsOK(res1)) {
21787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21788 }
21789 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21790 {
21791 PyThreadState* __tstate = wxPyBeginAllowThreads();
21792 delete arg1;
21793
21794 wxPyEndAllowThreads(__tstate);
21795 if (PyErr_Occurred()) SWIG_fail;
21796 }
21797 resultobj = SWIG_Py_Void();
21798 return resultobj;
21799 fail:
21800 return NULL;
21801 }
21802
21803
21804 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21805 PyObject *obj;
21806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21807 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21808 return SWIG_Py_Void();
21809 }
21810
21811 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21812 return SWIG_Python_InitShadowInstance(args);
21813 }
21814
21815 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21816 PyObject *resultobj = 0;
21817 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21818 wxString *arg2 = 0 ;
21819 wxConfigPathChanger *result = 0 ;
21820 void *argp1 = 0 ;
21821 int res1 = 0 ;
21822 bool temp2 = false ;
21823 PyObject * obj0 = 0 ;
21824 PyObject * obj1 = 0 ;
21825 char * kwnames[] = {
21826 (char *) "config",(char *) "entry", NULL
21827 };
21828
21829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21831 if (!SWIG_IsOK(res1)) {
21832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21833 }
21834 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21835 {
21836 arg2 = wxString_in_helper(obj1);
21837 if (arg2 == NULL) SWIG_fail;
21838 temp2 = true;
21839 }
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21843 wxPyEndAllowThreads(__tstate);
21844 if (PyErr_Occurred()) SWIG_fail;
21845 }
21846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21847 {
21848 if (temp2)
21849 delete arg2;
21850 }
21851 return resultobj;
21852 fail:
21853 {
21854 if (temp2)
21855 delete arg2;
21856 }
21857 return NULL;
21858 }
21859
21860
21861 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21862 PyObject *resultobj = 0;
21863 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21864 void *argp1 = 0 ;
21865 int res1 = 0 ;
21866 PyObject *swig_obj[1] ;
21867
21868 if (!args) SWIG_fail;
21869 swig_obj[0] = args;
21870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21871 if (!SWIG_IsOK(res1)) {
21872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21873 }
21874 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21875 {
21876 PyThreadState* __tstate = wxPyBeginAllowThreads();
21877 delete arg1;
21878
21879 wxPyEndAllowThreads(__tstate);
21880 if (PyErr_Occurred()) SWIG_fail;
21881 }
21882 resultobj = SWIG_Py_Void();
21883 return resultobj;
21884 fail:
21885 return NULL;
21886 }
21887
21888
21889 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21890 PyObject *resultobj = 0;
21891 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21892 wxString *result = 0 ;
21893 void *argp1 = 0 ;
21894 int res1 = 0 ;
21895 PyObject *swig_obj[1] ;
21896
21897 if (!args) SWIG_fail;
21898 swig_obj[0] = args;
21899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21900 if (!SWIG_IsOK(res1)) {
21901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21902 }
21903 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21904 {
21905 PyThreadState* __tstate = wxPyBeginAllowThreads();
21906 {
21907 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21908 result = (wxString *) &_result_ref;
21909 }
21910 wxPyEndAllowThreads(__tstate);
21911 if (PyErr_Occurred()) SWIG_fail;
21912 }
21913 {
21914 #if wxUSE_UNICODE
21915 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21916 #else
21917 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21918 #endif
21919 }
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21927 PyObject *obj;
21928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21929 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21930 return SWIG_Py_Void();
21931 }
21932
21933 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21934 return SWIG_Python_InitShadowInstance(args);
21935 }
21936
21937 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21938 PyObject *resultobj = 0;
21939 wxString *arg1 = 0 ;
21940 wxString result;
21941 bool temp1 = false ;
21942 PyObject * obj0 = 0 ;
21943 char * kwnames[] = {
21944 (char *) "sz", NULL
21945 };
21946
21947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21948 {
21949 arg1 = wxString_in_helper(obj0);
21950 if (arg1 == NULL) SWIG_fail;
21951 temp1 = true;
21952 }
21953 {
21954 PyThreadState* __tstate = wxPyBeginAllowThreads();
21955 result = wxExpandEnvVars((wxString const &)*arg1);
21956 wxPyEndAllowThreads(__tstate);
21957 if (PyErr_Occurred()) SWIG_fail;
21958 }
21959 {
21960 #if wxUSE_UNICODE
21961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21962 #else
21963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21964 #endif
21965 }
21966 {
21967 if (temp1)
21968 delete arg1;
21969 }
21970 return resultobj;
21971 fail:
21972 {
21973 if (temp1)
21974 delete arg1;
21975 }
21976 return NULL;
21977 }
21978
21979
21980 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21981 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21982 return 1;
21983 }
21984
21985
21986 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21987 PyObject *pyobj = 0;
21988
21989 {
21990 #if wxUSE_UNICODE
21991 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21992 #else
21993 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21994 #endif
21995 }
21996 return pyobj;
21997 }
21998
21999
22000 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22001 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22002 return 1;
22003 }
22004
22005
22006 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22007 PyObject *pyobj = 0;
22008
22009 {
22010 #if wxUSE_UNICODE
22011 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22012 #else
22013 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22014 #endif
22015 }
22016 return pyobj;
22017 }
22018
22019
22020 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22021 PyObject *resultobj = 0;
22022 wxDateTime::Country arg1 ;
22023 int val1 ;
22024 int ecode1 = 0 ;
22025 PyObject * obj0 = 0 ;
22026 char * kwnames[] = {
22027 (char *) "country", NULL
22028 };
22029
22030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22031 ecode1 = SWIG_AsVal_int(obj0, &val1);
22032 if (!SWIG_IsOK(ecode1)) {
22033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22034 }
22035 arg1 = static_cast< wxDateTime::Country >(val1);
22036 {
22037 PyThreadState* __tstate = wxPyBeginAllowThreads();
22038 wxDateTime::SetCountry(arg1);
22039 wxPyEndAllowThreads(__tstate);
22040 if (PyErr_Occurred()) SWIG_fail;
22041 }
22042 resultobj = SWIG_Py_Void();
22043 return resultobj;
22044 fail:
22045 return NULL;
22046 }
22047
22048
22049 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22050 PyObject *resultobj = 0;
22051 wxDateTime::Country result;
22052
22053 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (wxDateTime::Country)wxDateTime::GetCountry();
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 resultobj = SWIG_From_int(static_cast< int >(result));
22061 return resultobj;
22062 fail:
22063 return NULL;
22064 }
22065
22066
22067 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22068 PyObject *resultobj = 0;
22069 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22070 bool result;
22071 int val1 ;
22072 int ecode1 = 0 ;
22073 PyObject * obj0 = 0 ;
22074 char * kwnames[] = {
22075 (char *) "country", NULL
22076 };
22077
22078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22079 if (obj0) {
22080 ecode1 = SWIG_AsVal_int(obj0, &val1);
22081 if (!SWIG_IsOK(ecode1)) {
22082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22083 }
22084 arg1 = static_cast< wxDateTime::Country >(val1);
22085 }
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 {
22093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22094 }
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22102 PyObject *resultobj = 0;
22103 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22104 int result;
22105 int val1 ;
22106 int ecode1 = 0 ;
22107 PyObject * obj0 = 0 ;
22108 char * kwnames[] = {
22109 (char *) "cal", NULL
22110 };
22111
22112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
22113 if (obj0) {
22114 ecode1 = SWIG_AsVal_int(obj0, &val1);
22115 if (!SWIG_IsOK(ecode1)) {
22116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22117 }
22118 arg1 = static_cast< wxDateTime::Calendar >(val1);
22119 }
22120 {
22121 PyThreadState* __tstate = wxPyBeginAllowThreads();
22122 result = (int)wxDateTime::GetCurrentYear(arg1);
22123 wxPyEndAllowThreads(__tstate);
22124 if (PyErr_Occurred()) SWIG_fail;
22125 }
22126 resultobj = SWIG_From_int(static_cast< int >(result));
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22134 PyObject *resultobj = 0;
22135 int arg1 ;
22136 int result;
22137 int val1 ;
22138 int ecode1 = 0 ;
22139 PyObject * obj0 = 0 ;
22140 char * kwnames[] = {
22141 (char *) "year", NULL
22142 };
22143
22144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
22145 ecode1 = SWIG_AsVal_int(obj0, &val1);
22146 if (!SWIG_IsOK(ecode1)) {
22147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
22148 }
22149 arg1 = static_cast< int >(val1);
22150 {
22151 PyThreadState* __tstate = wxPyBeginAllowThreads();
22152 result = (int)wxDateTime::ConvertYearToBC(arg1);
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 resultobj = SWIG_From_int(static_cast< int >(result));
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj = 0;
22165 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22166 wxDateTime::Month result;
22167 int val1 ;
22168 int ecode1 = 0 ;
22169 PyObject * obj0 = 0 ;
22170 char * kwnames[] = {
22171 (char *) "cal", NULL
22172 };
22173
22174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22175 if (obj0) {
22176 ecode1 = SWIG_AsVal_int(obj0, &val1);
22177 if (!SWIG_IsOK(ecode1)) {
22178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22179 }
22180 arg1 = static_cast< wxDateTime::Calendar >(val1);
22181 }
22182 {
22183 PyThreadState* __tstate = wxPyBeginAllowThreads();
22184 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22185 wxPyEndAllowThreads(__tstate);
22186 if (PyErr_Occurred()) SWIG_fail;
22187 }
22188 resultobj = SWIG_From_int(static_cast< int >(result));
22189 return resultobj;
22190 fail:
22191 return NULL;
22192 }
22193
22194
22195 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22196 PyObject *resultobj = 0;
22197 int arg1 = (int) wxDateTime::Inv_Year ;
22198 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22199 bool result;
22200 int val1 ;
22201 int ecode1 = 0 ;
22202 int val2 ;
22203 int ecode2 = 0 ;
22204 PyObject * obj0 = 0 ;
22205 PyObject * obj1 = 0 ;
22206 char * kwnames[] = {
22207 (char *) "year",(char *) "cal", NULL
22208 };
22209
22210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22211 if (obj0) {
22212 ecode1 = SWIG_AsVal_int(obj0, &val1);
22213 if (!SWIG_IsOK(ecode1)) {
22214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22215 }
22216 arg1 = static_cast< int >(val1);
22217 }
22218 if (obj1) {
22219 ecode2 = SWIG_AsVal_int(obj1, &val2);
22220 if (!SWIG_IsOK(ecode2)) {
22221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22222 }
22223 arg2 = static_cast< wxDateTime::Calendar >(val2);
22224 }
22225 {
22226 PyThreadState* __tstate = wxPyBeginAllowThreads();
22227 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22228 wxPyEndAllowThreads(__tstate);
22229 if (PyErr_Occurred()) SWIG_fail;
22230 }
22231 {
22232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22233 }
22234 return resultobj;
22235 fail:
22236 return NULL;
22237 }
22238
22239
22240 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22241 PyObject *resultobj = 0;
22242 int arg1 = (int) wxDateTime::Inv_Year ;
22243 int result;
22244 int val1 ;
22245 int ecode1 = 0 ;
22246 PyObject * obj0 = 0 ;
22247 char * kwnames[] = {
22248 (char *) "year", NULL
22249 };
22250
22251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22252 if (obj0) {
22253 ecode1 = SWIG_AsVal_int(obj0, &val1);
22254 if (!SWIG_IsOK(ecode1)) {
22255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22256 }
22257 arg1 = static_cast< int >(val1);
22258 }
22259 {
22260 PyThreadState* __tstate = wxPyBeginAllowThreads();
22261 result = (int)wxDateTime::GetCentury(arg1);
22262 wxPyEndAllowThreads(__tstate);
22263 if (PyErr_Occurred()) SWIG_fail;
22264 }
22265 resultobj = SWIG_From_int(static_cast< int >(result));
22266 return resultobj;
22267 fail:
22268 return NULL;
22269 }
22270
22271
22272 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22273 PyObject *resultobj = 0;
22274 int arg1 ;
22275 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22276 int result;
22277 int val1 ;
22278 int ecode1 = 0 ;
22279 int val2 ;
22280 int ecode2 = 0 ;
22281 PyObject * obj0 = 0 ;
22282 PyObject * obj1 = 0 ;
22283 char * kwnames[] = {
22284 (char *) "year",(char *) "cal", NULL
22285 };
22286
22287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22288 ecode1 = SWIG_AsVal_int(obj0, &val1);
22289 if (!SWIG_IsOK(ecode1)) {
22290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22291 }
22292 arg1 = static_cast< int >(val1);
22293 if (obj1) {
22294 ecode2 = SWIG_AsVal_int(obj1, &val2);
22295 if (!SWIG_IsOK(ecode2)) {
22296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22297 }
22298 arg2 = static_cast< wxDateTime::Calendar >(val2);
22299 }
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 resultobj = SWIG_From_int(static_cast< int >(result));
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22314 PyObject *resultobj = 0;
22315 wxDateTime::Month arg1 ;
22316 int arg2 = (int) wxDateTime::Inv_Year ;
22317 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22318 int result;
22319 int val1 ;
22320 int ecode1 = 0 ;
22321 int val2 ;
22322 int ecode2 = 0 ;
22323 int val3 ;
22324 int ecode3 = 0 ;
22325 PyObject * obj0 = 0 ;
22326 PyObject * obj1 = 0 ;
22327 PyObject * obj2 = 0 ;
22328 char * kwnames[] = {
22329 (char *) "month",(char *) "year",(char *) "cal", NULL
22330 };
22331
22332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22333 ecode1 = SWIG_AsVal_int(obj0, &val1);
22334 if (!SWIG_IsOK(ecode1)) {
22335 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22336 }
22337 arg1 = static_cast< wxDateTime::Month >(val1);
22338 if (obj1) {
22339 ecode2 = SWIG_AsVal_int(obj1, &val2);
22340 if (!SWIG_IsOK(ecode2)) {
22341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22342 }
22343 arg2 = static_cast< int >(val2);
22344 }
22345 if (obj2) {
22346 ecode3 = SWIG_AsVal_int(obj2, &val3);
22347 if (!SWIG_IsOK(ecode3)) {
22348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22349 }
22350 arg3 = static_cast< wxDateTime::Calendar >(val3);
22351 }
22352 {
22353 PyThreadState* __tstate = wxPyBeginAllowThreads();
22354 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22355 wxPyEndAllowThreads(__tstate);
22356 if (PyErr_Occurred()) SWIG_fail;
22357 }
22358 resultobj = SWIG_From_int(static_cast< int >(result));
22359 return resultobj;
22360 fail:
22361 return NULL;
22362 }
22363
22364
22365 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22366 PyObject *resultobj = 0;
22367 wxDateTime::Month arg1 ;
22368 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22369 wxString result;
22370 int val1 ;
22371 int ecode1 = 0 ;
22372 int val2 ;
22373 int ecode2 = 0 ;
22374 PyObject * obj0 = 0 ;
22375 PyObject * obj1 = 0 ;
22376 char * kwnames[] = {
22377 (char *) "month",(char *) "flags", NULL
22378 };
22379
22380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22381 ecode1 = SWIG_AsVal_int(obj0, &val1);
22382 if (!SWIG_IsOK(ecode1)) {
22383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22384 }
22385 arg1 = static_cast< wxDateTime::Month >(val1);
22386 if (obj1) {
22387 ecode2 = SWIG_AsVal_int(obj1, &val2);
22388 if (!SWIG_IsOK(ecode2)) {
22389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22390 }
22391 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22392 }
22393 {
22394 PyThreadState* __tstate = wxPyBeginAllowThreads();
22395 result = wxDateTime::GetMonthName(arg1,arg2);
22396 wxPyEndAllowThreads(__tstate);
22397 if (PyErr_Occurred()) SWIG_fail;
22398 }
22399 {
22400 #if wxUSE_UNICODE
22401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22402 #else
22403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22404 #endif
22405 }
22406 return resultobj;
22407 fail:
22408 return NULL;
22409 }
22410
22411
22412 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22413 PyObject *resultobj = 0;
22414 wxDateTime::WeekDay arg1 ;
22415 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22416 wxString result;
22417 int val1 ;
22418 int ecode1 = 0 ;
22419 int val2 ;
22420 int ecode2 = 0 ;
22421 PyObject * obj0 = 0 ;
22422 PyObject * obj1 = 0 ;
22423 char * kwnames[] = {
22424 (char *) "weekday",(char *) "flags", NULL
22425 };
22426
22427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22428 ecode1 = SWIG_AsVal_int(obj0, &val1);
22429 if (!SWIG_IsOK(ecode1)) {
22430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22431 }
22432 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22433 if (obj1) {
22434 ecode2 = SWIG_AsVal_int(obj1, &val2);
22435 if (!SWIG_IsOK(ecode2)) {
22436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22437 }
22438 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22439 }
22440 {
22441 PyThreadState* __tstate = wxPyBeginAllowThreads();
22442 result = wxDateTime::GetWeekDayName(arg1,arg2);
22443 wxPyEndAllowThreads(__tstate);
22444 if (PyErr_Occurred()) SWIG_fail;
22445 }
22446 {
22447 #if wxUSE_UNICODE
22448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22449 #else
22450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22451 #endif
22452 }
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22460 PyObject *resultobj = 0;
22461 PyObject *result = 0 ;
22462
22463 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22464 {
22465 PyThreadState* __tstate = wxPyBeginAllowThreads();
22466 result = (PyObject *)wxDateTime_GetAmPmStrings();
22467 wxPyEndAllowThreads(__tstate);
22468 if (PyErr_Occurred()) SWIG_fail;
22469 }
22470 resultobj = result;
22471 return resultobj;
22472 fail:
22473 return NULL;
22474 }
22475
22476
22477 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22478 PyObject *resultobj = 0;
22479 int arg1 = (int) wxDateTime::Inv_Year ;
22480 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22481 bool result;
22482 int val1 ;
22483 int ecode1 = 0 ;
22484 int val2 ;
22485 int ecode2 = 0 ;
22486 PyObject * obj0 = 0 ;
22487 PyObject * obj1 = 0 ;
22488 char * kwnames[] = {
22489 (char *) "year",(char *) "country", NULL
22490 };
22491
22492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22493 if (obj0) {
22494 ecode1 = SWIG_AsVal_int(obj0, &val1);
22495 if (!SWIG_IsOK(ecode1)) {
22496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22497 }
22498 arg1 = static_cast< int >(val1);
22499 }
22500 if (obj1) {
22501 ecode2 = SWIG_AsVal_int(obj1, &val2);
22502 if (!SWIG_IsOK(ecode2)) {
22503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22504 }
22505 arg2 = static_cast< wxDateTime::Country >(val2);
22506 }
22507 {
22508 PyThreadState* __tstate = wxPyBeginAllowThreads();
22509 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22510 wxPyEndAllowThreads(__tstate);
22511 if (PyErr_Occurred()) SWIG_fail;
22512 }
22513 {
22514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22515 }
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22523 PyObject *resultobj = 0;
22524 int arg1 = (int) wxDateTime::Inv_Year ;
22525 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22526 wxDateTime result;
22527 int val1 ;
22528 int ecode1 = 0 ;
22529 int val2 ;
22530 int ecode2 = 0 ;
22531 PyObject * obj0 = 0 ;
22532 PyObject * obj1 = 0 ;
22533 char * kwnames[] = {
22534 (char *) "year",(char *) "country", NULL
22535 };
22536
22537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22538 if (obj0) {
22539 ecode1 = SWIG_AsVal_int(obj0, &val1);
22540 if (!SWIG_IsOK(ecode1)) {
22541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22542 }
22543 arg1 = static_cast< int >(val1);
22544 }
22545 if (obj1) {
22546 ecode2 = SWIG_AsVal_int(obj1, &val2);
22547 if (!SWIG_IsOK(ecode2)) {
22548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22549 }
22550 arg2 = static_cast< wxDateTime::Country >(val2);
22551 }
22552 {
22553 PyThreadState* __tstate = wxPyBeginAllowThreads();
22554 result = wxDateTime::GetBeginDST(arg1,arg2);
22555 wxPyEndAllowThreads(__tstate);
22556 if (PyErr_Occurred()) SWIG_fail;
22557 }
22558 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22559 return resultobj;
22560 fail:
22561 return NULL;
22562 }
22563
22564
22565 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22566 PyObject *resultobj = 0;
22567 int arg1 = (int) wxDateTime::Inv_Year ;
22568 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22569 wxDateTime result;
22570 int val1 ;
22571 int ecode1 = 0 ;
22572 int val2 ;
22573 int ecode2 = 0 ;
22574 PyObject * obj0 = 0 ;
22575 PyObject * obj1 = 0 ;
22576 char * kwnames[] = {
22577 (char *) "year",(char *) "country", NULL
22578 };
22579
22580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22581 if (obj0) {
22582 ecode1 = SWIG_AsVal_int(obj0, &val1);
22583 if (!SWIG_IsOK(ecode1)) {
22584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22585 }
22586 arg1 = static_cast< int >(val1);
22587 }
22588 if (obj1) {
22589 ecode2 = SWIG_AsVal_int(obj1, &val2);
22590 if (!SWIG_IsOK(ecode2)) {
22591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22592 }
22593 arg2 = static_cast< wxDateTime::Country >(val2);
22594 }
22595 {
22596 PyThreadState* __tstate = wxPyBeginAllowThreads();
22597 result = wxDateTime::GetEndDST(arg1,arg2);
22598 wxPyEndAllowThreads(__tstate);
22599 if (PyErr_Occurred()) SWIG_fail;
22600 }
22601 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22609 PyObject *resultobj = 0;
22610 wxDateTime result;
22611
22612 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22613 {
22614 PyThreadState* __tstate = wxPyBeginAllowThreads();
22615 result = wxDateTime::Now();
22616 wxPyEndAllowThreads(__tstate);
22617 if (PyErr_Occurred()) SWIG_fail;
22618 }
22619 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22620 return resultobj;
22621 fail:
22622 return NULL;
22623 }
22624
22625
22626 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22627 PyObject *resultobj = 0;
22628 wxDateTime result;
22629
22630 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = wxDateTime::UNow();
22634 wxPyEndAllowThreads(__tstate);
22635 if (PyErr_Occurred()) SWIG_fail;
22636 }
22637 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22638 return resultobj;
22639 fail:
22640 return NULL;
22641 }
22642
22643
22644 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22645 PyObject *resultobj = 0;
22646 wxDateTime result;
22647
22648 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22649 {
22650 PyThreadState* __tstate = wxPyBeginAllowThreads();
22651 result = wxDateTime::Today();
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 PyObject *resultobj = 0;
22664 wxDateTime *result = 0 ;
22665
22666 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22667 {
22668 PyThreadState* __tstate = wxPyBeginAllowThreads();
22669 result = (wxDateTime *)new wxDateTime();
22670 wxPyEndAllowThreads(__tstate);
22671 if (PyErr_Occurred()) SWIG_fail;
22672 }
22673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22681 PyObject *resultobj = 0;
22682 time_t arg1 ;
22683 wxDateTime *result = 0 ;
22684 unsigned int val1 ;
22685 int ecode1 = 0 ;
22686 PyObject * obj0 = 0 ;
22687 char * kwnames[] = {
22688 (char *) "timet", NULL
22689 };
22690
22691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22692 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22693 if (!SWIG_IsOK(ecode1)) {
22694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22695 }
22696 arg1 = static_cast< time_t >(val1);
22697 {
22698 PyThreadState* __tstate = wxPyBeginAllowThreads();
22699 result = (wxDateTime *)new wxDateTime(arg1);
22700 wxPyEndAllowThreads(__tstate);
22701 if (PyErr_Occurred()) SWIG_fail;
22702 }
22703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22711 PyObject *resultobj = 0;
22712 double arg1 ;
22713 wxDateTime *result = 0 ;
22714 double val1 ;
22715 int ecode1 = 0 ;
22716 PyObject * obj0 = 0 ;
22717 char * kwnames[] = {
22718 (char *) "jdn", NULL
22719 };
22720
22721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22722 ecode1 = SWIG_AsVal_double(obj0, &val1);
22723 if (!SWIG_IsOK(ecode1)) {
22724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22725 }
22726 arg1 = static_cast< double >(val1);
22727 {
22728 PyThreadState* __tstate = wxPyBeginAllowThreads();
22729 result = (wxDateTime *)new wxDateTime(arg1);
22730 wxPyEndAllowThreads(__tstate);
22731 if (PyErr_Occurred()) SWIG_fail;
22732 }
22733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22734 return resultobj;
22735 fail:
22736 return NULL;
22737 }
22738
22739
22740 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22741 PyObject *resultobj = 0;
22742 int arg1 ;
22743 int arg2 = (int) 0 ;
22744 int arg3 = (int) 0 ;
22745 int arg4 = (int) 0 ;
22746 wxDateTime *result = 0 ;
22747 int val1 ;
22748 int ecode1 = 0 ;
22749 int val2 ;
22750 int ecode2 = 0 ;
22751 int val3 ;
22752 int ecode3 = 0 ;
22753 int val4 ;
22754 int ecode4 = 0 ;
22755 PyObject * obj0 = 0 ;
22756 PyObject * obj1 = 0 ;
22757 PyObject * obj2 = 0 ;
22758 PyObject * obj3 = 0 ;
22759 char * kwnames[] = {
22760 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22761 };
22762
22763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22764 ecode1 = SWIG_AsVal_int(obj0, &val1);
22765 if (!SWIG_IsOK(ecode1)) {
22766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22767 }
22768 arg1 = static_cast< int >(val1);
22769 if (obj1) {
22770 ecode2 = SWIG_AsVal_int(obj1, &val2);
22771 if (!SWIG_IsOK(ecode2)) {
22772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22773 }
22774 arg2 = static_cast< int >(val2);
22775 }
22776 if (obj2) {
22777 ecode3 = SWIG_AsVal_int(obj2, &val3);
22778 if (!SWIG_IsOK(ecode3)) {
22779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22780 }
22781 arg3 = static_cast< int >(val3);
22782 }
22783 if (obj3) {
22784 ecode4 = SWIG_AsVal_int(obj3, &val4);
22785 if (!SWIG_IsOK(ecode4)) {
22786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22787 }
22788 arg4 = static_cast< int >(val4);
22789 }
22790 {
22791 PyThreadState* __tstate = wxPyBeginAllowThreads();
22792 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22793 wxPyEndAllowThreads(__tstate);
22794 if (PyErr_Occurred()) SWIG_fail;
22795 }
22796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22797 return resultobj;
22798 fail:
22799 return NULL;
22800 }
22801
22802
22803 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22804 PyObject *resultobj = 0;
22805 int arg1 ;
22806 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22807 int arg3 = (int) wxDateTime::Inv_Year ;
22808 int arg4 = (int) 0 ;
22809 int arg5 = (int) 0 ;
22810 int arg6 = (int) 0 ;
22811 int arg7 = (int) 0 ;
22812 wxDateTime *result = 0 ;
22813 int val1 ;
22814 int ecode1 = 0 ;
22815 int val2 ;
22816 int ecode2 = 0 ;
22817 int val3 ;
22818 int ecode3 = 0 ;
22819 int val4 ;
22820 int ecode4 = 0 ;
22821 int val5 ;
22822 int ecode5 = 0 ;
22823 int val6 ;
22824 int ecode6 = 0 ;
22825 int val7 ;
22826 int ecode7 = 0 ;
22827 PyObject * obj0 = 0 ;
22828 PyObject * obj1 = 0 ;
22829 PyObject * obj2 = 0 ;
22830 PyObject * obj3 = 0 ;
22831 PyObject * obj4 = 0 ;
22832 PyObject * obj5 = 0 ;
22833 PyObject * obj6 = 0 ;
22834 char * kwnames[] = {
22835 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22836 };
22837
22838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22839 ecode1 = SWIG_AsVal_int(obj0, &val1);
22840 if (!SWIG_IsOK(ecode1)) {
22841 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22842 }
22843 arg1 = static_cast< int >(val1);
22844 if (obj1) {
22845 ecode2 = SWIG_AsVal_int(obj1, &val2);
22846 if (!SWIG_IsOK(ecode2)) {
22847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22848 }
22849 arg2 = static_cast< wxDateTime::Month >(val2);
22850 }
22851 if (obj2) {
22852 ecode3 = SWIG_AsVal_int(obj2, &val3);
22853 if (!SWIG_IsOK(ecode3)) {
22854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22855 }
22856 arg3 = static_cast< int >(val3);
22857 }
22858 if (obj3) {
22859 ecode4 = SWIG_AsVal_int(obj3, &val4);
22860 if (!SWIG_IsOK(ecode4)) {
22861 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22862 }
22863 arg4 = static_cast< int >(val4);
22864 }
22865 if (obj4) {
22866 ecode5 = SWIG_AsVal_int(obj4, &val5);
22867 if (!SWIG_IsOK(ecode5)) {
22868 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22869 }
22870 arg5 = static_cast< int >(val5);
22871 }
22872 if (obj5) {
22873 ecode6 = SWIG_AsVal_int(obj5, &val6);
22874 if (!SWIG_IsOK(ecode6)) {
22875 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22876 }
22877 arg6 = static_cast< int >(val6);
22878 }
22879 if (obj6) {
22880 ecode7 = SWIG_AsVal_int(obj6, &val7);
22881 if (!SWIG_IsOK(ecode7)) {
22882 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22883 }
22884 arg7 = static_cast< int >(val7);
22885 }
22886 {
22887 PyThreadState* __tstate = wxPyBeginAllowThreads();
22888 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22889 wxPyEndAllowThreads(__tstate);
22890 if (PyErr_Occurred()) SWIG_fail;
22891 }
22892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22893 return resultobj;
22894 fail:
22895 return NULL;
22896 }
22897
22898
22899 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22900 PyObject *resultobj = 0;
22901 wxDateTime *arg1 = 0 ;
22902 wxDateTime *result = 0 ;
22903 void *argp1 = 0 ;
22904 int res1 = 0 ;
22905 PyObject * obj0 = 0 ;
22906 char * kwnames[] = {
22907 (char *) "date", NULL
22908 };
22909
22910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22911 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22912 if (!SWIG_IsOK(res1)) {
22913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22914 }
22915 if (!argp1) {
22916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22917 }
22918 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22919 {
22920 PyThreadState* __tstate = wxPyBeginAllowThreads();
22921 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22922 wxPyEndAllowThreads(__tstate);
22923 if (PyErr_Occurred()) SWIG_fail;
22924 }
22925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22926 return resultobj;
22927 fail:
22928 return NULL;
22929 }
22930
22931
22932 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22933 PyObject *resultobj = 0;
22934 wxDateTime *arg1 = (wxDateTime *) 0 ;
22935 void *argp1 = 0 ;
22936 int res1 = 0 ;
22937 PyObject *swig_obj[1] ;
22938
22939 if (!args) SWIG_fail;
22940 swig_obj[0] = args;
22941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22942 if (!SWIG_IsOK(res1)) {
22943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22944 }
22945 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 delete arg1;
22949
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 resultobj = SWIG_Py_Void();
22954 return resultobj;
22955 fail:
22956 return NULL;
22957 }
22958
22959
22960 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22961 PyObject *resultobj = 0;
22962 wxDateTime *arg1 = (wxDateTime *) 0 ;
22963 wxDateTime *result = 0 ;
22964 void *argp1 = 0 ;
22965 int res1 = 0 ;
22966 PyObject *swig_obj[1] ;
22967
22968 if (!args) SWIG_fail;
22969 swig_obj[0] = args;
22970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22971 if (!SWIG_IsOK(res1)) {
22972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22973 }
22974 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 {
22978 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22979 result = (wxDateTime *) &_result_ref;
22980 }
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22992 PyObject *resultobj = 0;
22993 wxDateTime *arg1 = (wxDateTime *) 0 ;
22994 time_t arg2 ;
22995 wxDateTime *result = 0 ;
22996 void *argp1 = 0 ;
22997 int res1 = 0 ;
22998 unsigned int val2 ;
22999 int ecode2 = 0 ;
23000 PyObject * obj0 = 0 ;
23001 PyObject * obj1 = 0 ;
23002 char * kwnames[] = {
23003 (char *) "self",(char *) "timet", NULL
23004 };
23005
23006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23008 if (!SWIG_IsOK(res1)) {
23009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23010 }
23011 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23012 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23013 if (!SWIG_IsOK(ecode2)) {
23014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23015 }
23016 arg2 = static_cast< time_t >(val2);
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 {
23020 wxDateTime &_result_ref = (arg1)->Set(arg2);
23021 result = (wxDateTime *) &_result_ref;
23022 }
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23034 PyObject *resultobj = 0;
23035 wxDateTime *arg1 = (wxDateTime *) 0 ;
23036 double arg2 ;
23037 wxDateTime *result = 0 ;
23038 void *argp1 = 0 ;
23039 int res1 = 0 ;
23040 double val2 ;
23041 int ecode2 = 0 ;
23042 PyObject * obj0 = 0 ;
23043 PyObject * obj1 = 0 ;
23044 char * kwnames[] = {
23045 (char *) "self",(char *) "jdn", NULL
23046 };
23047
23048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23050 if (!SWIG_IsOK(res1)) {
23051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23052 }
23053 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23054 ecode2 = SWIG_AsVal_double(obj1, &val2);
23055 if (!SWIG_IsOK(ecode2)) {
23056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23057 }
23058 arg2 = static_cast< double >(val2);
23059 {
23060 PyThreadState* __tstate = wxPyBeginAllowThreads();
23061 {
23062 wxDateTime &_result_ref = (arg1)->Set(arg2);
23063 result = (wxDateTime *) &_result_ref;
23064 }
23065 wxPyEndAllowThreads(__tstate);
23066 if (PyErr_Occurred()) SWIG_fail;
23067 }
23068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23076 PyObject *resultobj = 0;
23077 wxDateTime *arg1 = (wxDateTime *) 0 ;
23078 int arg2 ;
23079 int arg3 = (int) 0 ;
23080 int arg4 = (int) 0 ;
23081 int arg5 = (int) 0 ;
23082 wxDateTime *result = 0 ;
23083 void *argp1 = 0 ;
23084 int res1 = 0 ;
23085 int val2 ;
23086 int ecode2 = 0 ;
23087 int val3 ;
23088 int ecode3 = 0 ;
23089 int val4 ;
23090 int ecode4 = 0 ;
23091 int val5 ;
23092 int ecode5 = 0 ;
23093 PyObject * obj0 = 0 ;
23094 PyObject * obj1 = 0 ;
23095 PyObject * obj2 = 0 ;
23096 PyObject * obj3 = 0 ;
23097 PyObject * obj4 = 0 ;
23098 char * kwnames[] = {
23099 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23100 };
23101
23102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23104 if (!SWIG_IsOK(res1)) {
23105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
23106 }
23107 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23108 ecode2 = SWIG_AsVal_int(obj1, &val2);
23109 if (!SWIG_IsOK(ecode2)) {
23110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
23111 }
23112 arg2 = static_cast< int >(val2);
23113 if (obj2) {
23114 ecode3 = SWIG_AsVal_int(obj2, &val3);
23115 if (!SWIG_IsOK(ecode3)) {
23116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
23117 }
23118 arg3 = static_cast< int >(val3);
23119 }
23120 if (obj3) {
23121 ecode4 = SWIG_AsVal_int(obj3, &val4);
23122 if (!SWIG_IsOK(ecode4)) {
23123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
23124 }
23125 arg4 = static_cast< int >(val4);
23126 }
23127 if (obj4) {
23128 ecode5 = SWIG_AsVal_int(obj4, &val5);
23129 if (!SWIG_IsOK(ecode5)) {
23130 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
23131 }
23132 arg5 = static_cast< int >(val5);
23133 }
23134 {
23135 PyThreadState* __tstate = wxPyBeginAllowThreads();
23136 {
23137 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
23138 result = (wxDateTime *) &_result_ref;
23139 }
23140 wxPyEndAllowThreads(__tstate);
23141 if (PyErr_Occurred()) SWIG_fail;
23142 }
23143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23144 return resultobj;
23145 fail:
23146 return NULL;
23147 }
23148
23149
23150 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23151 PyObject *resultobj = 0;
23152 wxDateTime *arg1 = (wxDateTime *) 0 ;
23153 int arg2 ;
23154 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23155 int arg4 = (int) wxDateTime::Inv_Year ;
23156 int arg5 = (int) 0 ;
23157 int arg6 = (int) 0 ;
23158 int arg7 = (int) 0 ;
23159 int arg8 = (int) 0 ;
23160 wxDateTime *result = 0 ;
23161 void *argp1 = 0 ;
23162 int res1 = 0 ;
23163 int val2 ;
23164 int ecode2 = 0 ;
23165 int val3 ;
23166 int ecode3 = 0 ;
23167 int val4 ;
23168 int ecode4 = 0 ;
23169 int val5 ;
23170 int ecode5 = 0 ;
23171 int val6 ;
23172 int ecode6 = 0 ;
23173 int val7 ;
23174 int ecode7 = 0 ;
23175 int val8 ;
23176 int ecode8 = 0 ;
23177 PyObject * obj0 = 0 ;
23178 PyObject * obj1 = 0 ;
23179 PyObject * obj2 = 0 ;
23180 PyObject * obj3 = 0 ;
23181 PyObject * obj4 = 0 ;
23182 PyObject * obj5 = 0 ;
23183 PyObject * obj6 = 0 ;
23184 PyObject * obj7 = 0 ;
23185 char * kwnames[] = {
23186 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23187 };
23188
23189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23191 if (!SWIG_IsOK(res1)) {
23192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23193 }
23194 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23195 ecode2 = SWIG_AsVal_int(obj1, &val2);
23196 if (!SWIG_IsOK(ecode2)) {
23197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23198 }
23199 arg2 = static_cast< int >(val2);
23200 if (obj2) {
23201 ecode3 = SWIG_AsVal_int(obj2, &val3);
23202 if (!SWIG_IsOK(ecode3)) {
23203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23204 }
23205 arg3 = static_cast< wxDateTime::Month >(val3);
23206 }
23207 if (obj3) {
23208 ecode4 = SWIG_AsVal_int(obj3, &val4);
23209 if (!SWIG_IsOK(ecode4)) {
23210 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23211 }
23212 arg4 = static_cast< int >(val4);
23213 }
23214 if (obj4) {
23215 ecode5 = SWIG_AsVal_int(obj4, &val5);
23216 if (!SWIG_IsOK(ecode5)) {
23217 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23218 }
23219 arg5 = static_cast< int >(val5);
23220 }
23221 if (obj5) {
23222 ecode6 = SWIG_AsVal_int(obj5, &val6);
23223 if (!SWIG_IsOK(ecode6)) {
23224 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23225 }
23226 arg6 = static_cast< int >(val6);
23227 }
23228 if (obj6) {
23229 ecode7 = SWIG_AsVal_int(obj6, &val7);
23230 if (!SWIG_IsOK(ecode7)) {
23231 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23232 }
23233 arg7 = static_cast< int >(val7);
23234 }
23235 if (obj7) {
23236 ecode8 = SWIG_AsVal_int(obj7, &val8);
23237 if (!SWIG_IsOK(ecode8)) {
23238 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23239 }
23240 arg8 = static_cast< int >(val8);
23241 }
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 {
23245 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23246 result = (wxDateTime *) &_result_ref;
23247 }
23248 wxPyEndAllowThreads(__tstate);
23249 if (PyErr_Occurred()) SWIG_fail;
23250 }
23251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23259 PyObject *resultobj = 0;
23260 wxDateTime *arg1 = (wxDateTime *) 0 ;
23261 wxDateTime *result = 0 ;
23262 void *argp1 = 0 ;
23263 int res1 = 0 ;
23264 PyObject *swig_obj[1] ;
23265
23266 if (!args) SWIG_fail;
23267 swig_obj[0] = args;
23268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23269 if (!SWIG_IsOK(res1)) {
23270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23271 }
23272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23273 {
23274 PyThreadState* __tstate = wxPyBeginAllowThreads();
23275 {
23276 wxDateTime &_result_ref = (arg1)->ResetTime();
23277 result = (wxDateTime *) &_result_ref;
23278 }
23279 wxPyEndAllowThreads(__tstate);
23280 if (PyErr_Occurred()) SWIG_fail;
23281 }
23282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23283 return resultobj;
23284 fail:
23285 return NULL;
23286 }
23287
23288
23289 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23290 PyObject *resultobj = 0;
23291 wxDateTime *arg1 = (wxDateTime *) 0 ;
23292 int arg2 ;
23293 wxDateTime *result = 0 ;
23294 void *argp1 = 0 ;
23295 int res1 = 0 ;
23296 int val2 ;
23297 int ecode2 = 0 ;
23298 PyObject * obj0 = 0 ;
23299 PyObject * obj1 = 0 ;
23300 char * kwnames[] = {
23301 (char *) "self",(char *) "year", NULL
23302 };
23303
23304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23306 if (!SWIG_IsOK(res1)) {
23307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23308 }
23309 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23310 ecode2 = SWIG_AsVal_int(obj1, &val2);
23311 if (!SWIG_IsOK(ecode2)) {
23312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23313 }
23314 arg2 = static_cast< int >(val2);
23315 {
23316 PyThreadState* __tstate = wxPyBeginAllowThreads();
23317 {
23318 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23319 result = (wxDateTime *) &_result_ref;
23320 }
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj = 0;
23333 wxDateTime *arg1 = (wxDateTime *) 0 ;
23334 wxDateTime::Month arg2 ;
23335 wxDateTime *result = 0 ;
23336 void *argp1 = 0 ;
23337 int res1 = 0 ;
23338 int val2 ;
23339 int ecode2 = 0 ;
23340 PyObject * obj0 = 0 ;
23341 PyObject * obj1 = 0 ;
23342 char * kwnames[] = {
23343 (char *) "self",(char *) "month", NULL
23344 };
23345
23346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23348 if (!SWIG_IsOK(res1)) {
23349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23350 }
23351 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23352 ecode2 = SWIG_AsVal_int(obj1, &val2);
23353 if (!SWIG_IsOK(ecode2)) {
23354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23355 }
23356 arg2 = static_cast< wxDateTime::Month >(val2);
23357 {
23358 PyThreadState* __tstate = wxPyBeginAllowThreads();
23359 {
23360 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23361 result = (wxDateTime *) &_result_ref;
23362 }
23363 wxPyEndAllowThreads(__tstate);
23364 if (PyErr_Occurred()) SWIG_fail;
23365 }
23366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23367 return resultobj;
23368 fail:
23369 return NULL;
23370 }
23371
23372
23373 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23374 PyObject *resultobj = 0;
23375 wxDateTime *arg1 = (wxDateTime *) 0 ;
23376 int arg2 ;
23377 wxDateTime *result = 0 ;
23378 void *argp1 = 0 ;
23379 int res1 = 0 ;
23380 int val2 ;
23381 int ecode2 = 0 ;
23382 PyObject * obj0 = 0 ;
23383 PyObject * obj1 = 0 ;
23384 char * kwnames[] = {
23385 (char *) "self",(char *) "day", NULL
23386 };
23387
23388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23390 if (!SWIG_IsOK(res1)) {
23391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23392 }
23393 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23394 ecode2 = SWIG_AsVal_int(obj1, &val2);
23395 if (!SWIG_IsOK(ecode2)) {
23396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23397 }
23398 arg2 = static_cast< int >(val2);
23399 {
23400 PyThreadState* __tstate = wxPyBeginAllowThreads();
23401 {
23402 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23403 result = (wxDateTime *) &_result_ref;
23404 }
23405 wxPyEndAllowThreads(__tstate);
23406 if (PyErr_Occurred()) SWIG_fail;
23407 }
23408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23409 return resultobj;
23410 fail:
23411 return NULL;
23412 }
23413
23414
23415 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23416 PyObject *resultobj = 0;
23417 wxDateTime *arg1 = (wxDateTime *) 0 ;
23418 int arg2 ;
23419 wxDateTime *result = 0 ;
23420 void *argp1 = 0 ;
23421 int res1 = 0 ;
23422 int val2 ;
23423 int ecode2 = 0 ;
23424 PyObject * obj0 = 0 ;
23425 PyObject * obj1 = 0 ;
23426 char * kwnames[] = {
23427 (char *) "self",(char *) "hour", NULL
23428 };
23429
23430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23432 if (!SWIG_IsOK(res1)) {
23433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23434 }
23435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23436 ecode2 = SWIG_AsVal_int(obj1, &val2);
23437 if (!SWIG_IsOK(ecode2)) {
23438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23439 }
23440 arg2 = static_cast< int >(val2);
23441 {
23442 PyThreadState* __tstate = wxPyBeginAllowThreads();
23443 {
23444 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23445 result = (wxDateTime *) &_result_ref;
23446 }
23447 wxPyEndAllowThreads(__tstate);
23448 if (PyErr_Occurred()) SWIG_fail;
23449 }
23450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23458 PyObject *resultobj = 0;
23459 wxDateTime *arg1 = (wxDateTime *) 0 ;
23460 int arg2 ;
23461 wxDateTime *result = 0 ;
23462 void *argp1 = 0 ;
23463 int res1 = 0 ;
23464 int val2 ;
23465 int ecode2 = 0 ;
23466 PyObject * obj0 = 0 ;
23467 PyObject * obj1 = 0 ;
23468 char * kwnames[] = {
23469 (char *) "self",(char *) "minute", NULL
23470 };
23471
23472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23474 if (!SWIG_IsOK(res1)) {
23475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23476 }
23477 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23478 ecode2 = SWIG_AsVal_int(obj1, &val2);
23479 if (!SWIG_IsOK(ecode2)) {
23480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23481 }
23482 arg2 = static_cast< int >(val2);
23483 {
23484 PyThreadState* __tstate = wxPyBeginAllowThreads();
23485 {
23486 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23487 result = (wxDateTime *) &_result_ref;
23488 }
23489 wxPyEndAllowThreads(__tstate);
23490 if (PyErr_Occurred()) SWIG_fail;
23491 }
23492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23493 return resultobj;
23494 fail:
23495 return NULL;
23496 }
23497
23498
23499 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23500 PyObject *resultobj = 0;
23501 wxDateTime *arg1 = (wxDateTime *) 0 ;
23502 int arg2 ;
23503 wxDateTime *result = 0 ;
23504 void *argp1 = 0 ;
23505 int res1 = 0 ;
23506 int val2 ;
23507 int ecode2 = 0 ;
23508 PyObject * obj0 = 0 ;
23509 PyObject * obj1 = 0 ;
23510 char * kwnames[] = {
23511 (char *) "self",(char *) "second", NULL
23512 };
23513
23514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23516 if (!SWIG_IsOK(res1)) {
23517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23518 }
23519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23520 ecode2 = SWIG_AsVal_int(obj1, &val2);
23521 if (!SWIG_IsOK(ecode2)) {
23522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23523 }
23524 arg2 = static_cast< int >(val2);
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 {
23528 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23529 result = (wxDateTime *) &_result_ref;
23530 }
23531 wxPyEndAllowThreads(__tstate);
23532 if (PyErr_Occurred()) SWIG_fail;
23533 }
23534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23542 PyObject *resultobj = 0;
23543 wxDateTime *arg1 = (wxDateTime *) 0 ;
23544 int arg2 ;
23545 wxDateTime *result = 0 ;
23546 void *argp1 = 0 ;
23547 int res1 = 0 ;
23548 int val2 ;
23549 int ecode2 = 0 ;
23550 PyObject * obj0 = 0 ;
23551 PyObject * obj1 = 0 ;
23552 char * kwnames[] = {
23553 (char *) "self",(char *) "millisecond", NULL
23554 };
23555
23556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23558 if (!SWIG_IsOK(res1)) {
23559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23560 }
23561 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23562 ecode2 = SWIG_AsVal_int(obj1, &val2);
23563 if (!SWIG_IsOK(ecode2)) {
23564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23565 }
23566 arg2 = static_cast< int >(val2);
23567 {
23568 PyThreadState* __tstate = wxPyBeginAllowThreads();
23569 {
23570 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23571 result = (wxDateTime *) &_result_ref;
23572 }
23573 wxPyEndAllowThreads(__tstate);
23574 if (PyErr_Occurred()) SWIG_fail;
23575 }
23576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23584 PyObject *resultobj = 0;
23585 wxDateTime *arg1 = (wxDateTime *) 0 ;
23586 wxDateTime::WeekDay arg2 ;
23587 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23588 wxDateTime *result = 0 ;
23589 void *argp1 = 0 ;
23590 int res1 = 0 ;
23591 int val2 ;
23592 int ecode2 = 0 ;
23593 int val3 ;
23594 int ecode3 = 0 ;
23595 PyObject * obj0 = 0 ;
23596 PyObject * obj1 = 0 ;
23597 PyObject * obj2 = 0 ;
23598 char * kwnames[] = {
23599 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23600 };
23601
23602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23604 if (!SWIG_IsOK(res1)) {
23605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23606 }
23607 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23608 ecode2 = SWIG_AsVal_int(obj1, &val2);
23609 if (!SWIG_IsOK(ecode2)) {
23610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23611 }
23612 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23613 if (obj2) {
23614 ecode3 = SWIG_AsVal_int(obj2, &val3);
23615 if (!SWIG_IsOK(ecode3)) {
23616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23617 }
23618 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23619 }
23620 {
23621 PyThreadState* __tstate = wxPyBeginAllowThreads();
23622 {
23623 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23624 result = (wxDateTime *) &_result_ref;
23625 }
23626 wxPyEndAllowThreads(__tstate);
23627 if (PyErr_Occurred()) SWIG_fail;
23628 }
23629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23630 return resultobj;
23631 fail:
23632 return NULL;
23633 }
23634
23635
23636 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23637 PyObject *resultobj = 0;
23638 wxDateTime *arg1 = (wxDateTime *) 0 ;
23639 wxDateTime::WeekDay arg2 ;
23640 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23641 wxDateTime result;
23642 void *argp1 = 0 ;
23643 int res1 = 0 ;
23644 int val2 ;
23645 int ecode2 = 0 ;
23646 int val3 ;
23647 int ecode3 = 0 ;
23648 PyObject * obj0 = 0 ;
23649 PyObject * obj1 = 0 ;
23650 PyObject * obj2 = 0 ;
23651 char * kwnames[] = {
23652 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23653 };
23654
23655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23657 if (!SWIG_IsOK(res1)) {
23658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23659 }
23660 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23661 ecode2 = SWIG_AsVal_int(obj1, &val2);
23662 if (!SWIG_IsOK(ecode2)) {
23663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23664 }
23665 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23666 if (obj2) {
23667 ecode3 = SWIG_AsVal_int(obj2, &val3);
23668 if (!SWIG_IsOK(ecode3)) {
23669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23670 }
23671 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23672 }
23673 {
23674 PyThreadState* __tstate = wxPyBeginAllowThreads();
23675 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23687 PyObject *resultobj = 0;
23688 wxDateTime *arg1 = (wxDateTime *) 0 ;
23689 wxDateTime::WeekDay arg2 ;
23690 wxDateTime *result = 0 ;
23691 void *argp1 = 0 ;
23692 int res1 = 0 ;
23693 int val2 ;
23694 int ecode2 = 0 ;
23695 PyObject * obj0 = 0 ;
23696 PyObject * obj1 = 0 ;
23697 char * kwnames[] = {
23698 (char *) "self",(char *) "weekday", NULL
23699 };
23700
23701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23703 if (!SWIG_IsOK(res1)) {
23704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23705 }
23706 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23707 ecode2 = SWIG_AsVal_int(obj1, &val2);
23708 if (!SWIG_IsOK(ecode2)) {
23709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23710 }
23711 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23712 {
23713 PyThreadState* __tstate = wxPyBeginAllowThreads();
23714 {
23715 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23716 result = (wxDateTime *) &_result_ref;
23717 }
23718 wxPyEndAllowThreads(__tstate);
23719 if (PyErr_Occurred()) SWIG_fail;
23720 }
23721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23722 return resultobj;
23723 fail:
23724 return NULL;
23725 }
23726
23727
23728 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23729 PyObject *resultobj = 0;
23730 wxDateTime *arg1 = (wxDateTime *) 0 ;
23731 wxDateTime::WeekDay arg2 ;
23732 wxDateTime result;
23733 void *argp1 = 0 ;
23734 int res1 = 0 ;
23735 int val2 ;
23736 int ecode2 = 0 ;
23737 PyObject * obj0 = 0 ;
23738 PyObject * obj1 = 0 ;
23739 char * kwnames[] = {
23740 (char *) "self",(char *) "weekday", NULL
23741 };
23742
23743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23745 if (!SWIG_IsOK(res1)) {
23746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23747 }
23748 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23749 ecode2 = SWIG_AsVal_int(obj1, &val2);
23750 if (!SWIG_IsOK(ecode2)) {
23751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23752 }
23753 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23754 {
23755 PyThreadState* __tstate = wxPyBeginAllowThreads();
23756 result = (arg1)->GetNextWeekDay(arg2);
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23761 return resultobj;
23762 fail:
23763 return NULL;
23764 }
23765
23766
23767 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23768 PyObject *resultobj = 0;
23769 wxDateTime *arg1 = (wxDateTime *) 0 ;
23770 wxDateTime::WeekDay arg2 ;
23771 wxDateTime *result = 0 ;
23772 void *argp1 = 0 ;
23773 int res1 = 0 ;
23774 int val2 ;
23775 int ecode2 = 0 ;
23776 PyObject * obj0 = 0 ;
23777 PyObject * obj1 = 0 ;
23778 char * kwnames[] = {
23779 (char *) "self",(char *) "weekday", NULL
23780 };
23781
23782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23784 if (!SWIG_IsOK(res1)) {
23785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23786 }
23787 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23788 ecode2 = SWIG_AsVal_int(obj1, &val2);
23789 if (!SWIG_IsOK(ecode2)) {
23790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23791 }
23792 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23793 {
23794 PyThreadState* __tstate = wxPyBeginAllowThreads();
23795 {
23796 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23797 result = (wxDateTime *) &_result_ref;
23798 }
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23810 PyObject *resultobj = 0;
23811 wxDateTime *arg1 = (wxDateTime *) 0 ;
23812 wxDateTime::WeekDay arg2 ;
23813 wxDateTime result;
23814 void *argp1 = 0 ;
23815 int res1 = 0 ;
23816 int val2 ;
23817 int ecode2 = 0 ;
23818 PyObject * obj0 = 0 ;
23819 PyObject * obj1 = 0 ;
23820 char * kwnames[] = {
23821 (char *) "self",(char *) "weekday", NULL
23822 };
23823
23824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23826 if (!SWIG_IsOK(res1)) {
23827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23828 }
23829 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23830 ecode2 = SWIG_AsVal_int(obj1, &val2);
23831 if (!SWIG_IsOK(ecode2)) {
23832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23833 }
23834 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23835 {
23836 PyThreadState* __tstate = wxPyBeginAllowThreads();
23837 result = (arg1)->GetPrevWeekDay(arg2);
23838 wxPyEndAllowThreads(__tstate);
23839 if (PyErr_Occurred()) SWIG_fail;
23840 }
23841 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23842 return resultobj;
23843 fail:
23844 return NULL;
23845 }
23846
23847
23848 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23849 PyObject *resultobj = 0;
23850 wxDateTime *arg1 = (wxDateTime *) 0 ;
23851 wxDateTime::WeekDay arg2 ;
23852 int arg3 = (int) 1 ;
23853 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23854 int arg5 = (int) wxDateTime::Inv_Year ;
23855 bool result;
23856 void *argp1 = 0 ;
23857 int res1 = 0 ;
23858 int val2 ;
23859 int ecode2 = 0 ;
23860 int val3 ;
23861 int ecode3 = 0 ;
23862 int val4 ;
23863 int ecode4 = 0 ;
23864 int val5 ;
23865 int ecode5 = 0 ;
23866 PyObject * obj0 = 0 ;
23867 PyObject * obj1 = 0 ;
23868 PyObject * obj2 = 0 ;
23869 PyObject * obj3 = 0 ;
23870 PyObject * obj4 = 0 ;
23871 char * kwnames[] = {
23872 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23873 };
23874
23875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23877 if (!SWIG_IsOK(res1)) {
23878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23879 }
23880 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23881 ecode2 = SWIG_AsVal_int(obj1, &val2);
23882 if (!SWIG_IsOK(ecode2)) {
23883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23884 }
23885 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23886 if (obj2) {
23887 ecode3 = SWIG_AsVal_int(obj2, &val3);
23888 if (!SWIG_IsOK(ecode3)) {
23889 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23890 }
23891 arg3 = static_cast< int >(val3);
23892 }
23893 if (obj3) {
23894 ecode4 = SWIG_AsVal_int(obj3, &val4);
23895 if (!SWIG_IsOK(ecode4)) {
23896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23897 }
23898 arg4 = static_cast< wxDateTime::Month >(val4);
23899 }
23900 if (obj4) {
23901 ecode5 = SWIG_AsVal_int(obj4, &val5);
23902 if (!SWIG_IsOK(ecode5)) {
23903 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23904 }
23905 arg5 = static_cast< int >(val5);
23906 }
23907 {
23908 PyThreadState* __tstate = wxPyBeginAllowThreads();
23909 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23910 wxPyEndAllowThreads(__tstate);
23911 if (PyErr_Occurred()) SWIG_fail;
23912 }
23913 {
23914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23915 }
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23923 PyObject *resultobj = 0;
23924 wxDateTime *arg1 = (wxDateTime *) 0 ;
23925 wxDateTime::WeekDay arg2 ;
23926 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23927 int arg4 = (int) wxDateTime::Inv_Year ;
23928 bool result;
23929 void *argp1 = 0 ;
23930 int res1 = 0 ;
23931 int val2 ;
23932 int ecode2 = 0 ;
23933 int val3 ;
23934 int ecode3 = 0 ;
23935 int val4 ;
23936 int ecode4 = 0 ;
23937 PyObject * obj0 = 0 ;
23938 PyObject * obj1 = 0 ;
23939 PyObject * obj2 = 0 ;
23940 PyObject * obj3 = 0 ;
23941 char * kwnames[] = {
23942 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23943 };
23944
23945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23947 if (!SWIG_IsOK(res1)) {
23948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23949 }
23950 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23951 ecode2 = SWIG_AsVal_int(obj1, &val2);
23952 if (!SWIG_IsOK(ecode2)) {
23953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23954 }
23955 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23956 if (obj2) {
23957 ecode3 = SWIG_AsVal_int(obj2, &val3);
23958 if (!SWIG_IsOK(ecode3)) {
23959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23960 }
23961 arg3 = static_cast< wxDateTime::Month >(val3);
23962 }
23963 if (obj3) {
23964 ecode4 = SWIG_AsVal_int(obj3, &val4);
23965 if (!SWIG_IsOK(ecode4)) {
23966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23967 }
23968 arg4 = static_cast< int >(val4);
23969 }
23970 {
23971 PyThreadState* __tstate = wxPyBeginAllowThreads();
23972 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23973 wxPyEndAllowThreads(__tstate);
23974 if (PyErr_Occurred()) SWIG_fail;
23975 }
23976 {
23977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23978 }
23979 return resultobj;
23980 fail:
23981 return NULL;
23982 }
23983
23984
23985 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23986 PyObject *resultobj = 0;
23987 wxDateTime *arg1 = (wxDateTime *) 0 ;
23988 wxDateTime::WeekDay arg2 ;
23989 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23990 int arg4 = (int) wxDateTime::Inv_Year ;
23991 wxDateTime result;
23992 void *argp1 = 0 ;
23993 int res1 = 0 ;
23994 int val2 ;
23995 int ecode2 = 0 ;
23996 int val3 ;
23997 int ecode3 = 0 ;
23998 int val4 ;
23999 int ecode4 = 0 ;
24000 PyObject * obj0 = 0 ;
24001 PyObject * obj1 = 0 ;
24002 PyObject * obj2 = 0 ;
24003 PyObject * obj3 = 0 ;
24004 char * kwnames[] = {
24005 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24006 };
24007
24008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24010 if (!SWIG_IsOK(res1)) {
24011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24012 }
24013 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24014 ecode2 = SWIG_AsVal_int(obj1, &val2);
24015 if (!SWIG_IsOK(ecode2)) {
24016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24017 }
24018 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24019 if (obj2) {
24020 ecode3 = SWIG_AsVal_int(obj2, &val3);
24021 if (!SWIG_IsOK(ecode3)) {
24022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24023 }
24024 arg3 = static_cast< wxDateTime::Month >(val3);
24025 }
24026 if (obj3) {
24027 ecode4 = SWIG_AsVal_int(obj3, &val4);
24028 if (!SWIG_IsOK(ecode4)) {
24029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24030 }
24031 arg4 = static_cast< int >(val4);
24032 }
24033 {
24034 PyThreadState* __tstate = wxPyBeginAllowThreads();
24035 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24036 wxPyEndAllowThreads(__tstate);
24037 if (PyErr_Occurred()) SWIG_fail;
24038 }
24039 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24040 return resultobj;
24041 fail:
24042 return NULL;
24043 }
24044
24045
24046 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24047 PyObject *resultobj = 0;
24048 wxDateTime *arg1 = (wxDateTime *) 0 ;
24049 int arg2 ;
24050 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24051 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24052 bool result;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 int val2 ;
24056 int ecode2 = 0 ;
24057 int val3 ;
24058 int ecode3 = 0 ;
24059 int val4 ;
24060 int ecode4 = 0 ;
24061 PyObject * obj0 = 0 ;
24062 PyObject * obj1 = 0 ;
24063 PyObject * obj2 = 0 ;
24064 PyObject * obj3 = 0 ;
24065 char * kwnames[] = {
24066 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24067 };
24068
24069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24071 if (!SWIG_IsOK(res1)) {
24072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24073 }
24074 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24075 ecode2 = SWIG_AsVal_int(obj1, &val2);
24076 if (!SWIG_IsOK(ecode2)) {
24077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24078 }
24079 arg2 = static_cast< int >(val2);
24080 if (obj2) {
24081 ecode3 = SWIG_AsVal_int(obj2, &val3);
24082 if (!SWIG_IsOK(ecode3)) {
24083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24084 }
24085 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24086 }
24087 if (obj3) {
24088 ecode4 = SWIG_AsVal_int(obj3, &val4);
24089 if (!SWIG_IsOK(ecode4)) {
24090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24091 }
24092 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24093 }
24094 {
24095 PyThreadState* __tstate = wxPyBeginAllowThreads();
24096 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 {
24101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24102 }
24103 return resultobj;
24104 fail:
24105 return NULL;
24106 }
24107
24108
24109 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24110 PyObject *resultobj = 0;
24111 wxDateTime *arg1 = (wxDateTime *) 0 ;
24112 int arg2 ;
24113 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24114 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24115 wxDateTime result;
24116 void *argp1 = 0 ;
24117 int res1 = 0 ;
24118 int val2 ;
24119 int ecode2 = 0 ;
24120 int val3 ;
24121 int ecode3 = 0 ;
24122 int val4 ;
24123 int ecode4 = 0 ;
24124 PyObject * obj0 = 0 ;
24125 PyObject * obj1 = 0 ;
24126 PyObject * obj2 = 0 ;
24127 PyObject * obj3 = 0 ;
24128 char * kwnames[] = {
24129 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24130 };
24131
24132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24134 if (!SWIG_IsOK(res1)) {
24135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24136 }
24137 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24138 ecode2 = SWIG_AsVal_int(obj1, &val2);
24139 if (!SWIG_IsOK(ecode2)) {
24140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
24141 }
24142 arg2 = static_cast< int >(val2);
24143 if (obj2) {
24144 ecode3 = SWIG_AsVal_int(obj2, &val3);
24145 if (!SWIG_IsOK(ecode3)) {
24146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24147 }
24148 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24149 }
24150 if (obj3) {
24151 ecode4 = SWIG_AsVal_int(obj3, &val4);
24152 if (!SWIG_IsOK(ecode4)) {
24153 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24154 }
24155 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24156 }
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (arg1)->GetWeek(arg2,arg3,arg4);
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24164 return resultobj;
24165 fail:
24166 return NULL;
24167 }
24168
24169
24170 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24171 PyObject *resultobj = 0;
24172 int arg1 ;
24173 int arg2 ;
24174 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24175 wxDateTime result;
24176 int val1 ;
24177 int ecode1 = 0 ;
24178 int val2 ;
24179 int ecode2 = 0 ;
24180 int val3 ;
24181 int ecode3 = 0 ;
24182 PyObject * obj0 = 0 ;
24183 PyObject * obj1 = 0 ;
24184 PyObject * obj2 = 0 ;
24185 char * kwnames[] = {
24186 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24187 };
24188
24189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24190 ecode1 = SWIG_AsVal_int(obj0, &val1);
24191 if (!SWIG_IsOK(ecode1)) {
24192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24193 }
24194 arg1 = static_cast< int >(val1);
24195 ecode2 = SWIG_AsVal_int(obj1, &val2);
24196 if (!SWIG_IsOK(ecode2)) {
24197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24198 }
24199 arg2 = static_cast< int >(val2);
24200 if (obj2) {
24201 ecode3 = SWIG_AsVal_int(obj2, &val3);
24202 if (!SWIG_IsOK(ecode3)) {
24203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24204 }
24205 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24206 }
24207 {
24208 PyThreadState* __tstate = wxPyBeginAllowThreads();
24209 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24210 wxPyEndAllowThreads(__tstate);
24211 if (PyErr_Occurred()) SWIG_fail;
24212 }
24213 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24214 return resultobj;
24215 fail:
24216 return NULL;
24217 }
24218
24219
24220 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24221 PyObject *resultobj = 0;
24222 wxDateTime *arg1 = (wxDateTime *) 0 ;
24223 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24224 int arg3 = (int) wxDateTime::Inv_Year ;
24225 wxDateTime *result = 0 ;
24226 void *argp1 = 0 ;
24227 int res1 = 0 ;
24228 int val2 ;
24229 int ecode2 = 0 ;
24230 int val3 ;
24231 int ecode3 = 0 ;
24232 PyObject * obj0 = 0 ;
24233 PyObject * obj1 = 0 ;
24234 PyObject * obj2 = 0 ;
24235 char * kwnames[] = {
24236 (char *) "self",(char *) "month",(char *) "year", NULL
24237 };
24238
24239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24241 if (!SWIG_IsOK(res1)) {
24242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24243 }
24244 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24245 if (obj1) {
24246 ecode2 = SWIG_AsVal_int(obj1, &val2);
24247 if (!SWIG_IsOK(ecode2)) {
24248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24249 }
24250 arg2 = static_cast< wxDateTime::Month >(val2);
24251 }
24252 if (obj2) {
24253 ecode3 = SWIG_AsVal_int(obj2, &val3);
24254 if (!SWIG_IsOK(ecode3)) {
24255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24256 }
24257 arg3 = static_cast< int >(val3);
24258 }
24259 {
24260 PyThreadState* __tstate = wxPyBeginAllowThreads();
24261 {
24262 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24263 result = (wxDateTime *) &_result_ref;
24264 }
24265 wxPyEndAllowThreads(__tstate);
24266 if (PyErr_Occurred()) SWIG_fail;
24267 }
24268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24269 return resultobj;
24270 fail:
24271 return NULL;
24272 }
24273
24274
24275 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24276 PyObject *resultobj = 0;
24277 wxDateTime *arg1 = (wxDateTime *) 0 ;
24278 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24279 int arg3 = (int) wxDateTime::Inv_Year ;
24280 wxDateTime result;
24281 void *argp1 = 0 ;
24282 int res1 = 0 ;
24283 int val2 ;
24284 int ecode2 = 0 ;
24285 int val3 ;
24286 int ecode3 = 0 ;
24287 PyObject * obj0 = 0 ;
24288 PyObject * obj1 = 0 ;
24289 PyObject * obj2 = 0 ;
24290 char * kwnames[] = {
24291 (char *) "self",(char *) "month",(char *) "year", NULL
24292 };
24293
24294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24296 if (!SWIG_IsOK(res1)) {
24297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24298 }
24299 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24300 if (obj1) {
24301 ecode2 = SWIG_AsVal_int(obj1, &val2);
24302 if (!SWIG_IsOK(ecode2)) {
24303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24304 }
24305 arg2 = static_cast< wxDateTime::Month >(val2);
24306 }
24307 if (obj2) {
24308 ecode3 = SWIG_AsVal_int(obj2, &val3);
24309 if (!SWIG_IsOK(ecode3)) {
24310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24311 }
24312 arg3 = static_cast< int >(val3);
24313 }
24314 {
24315 PyThreadState* __tstate = wxPyBeginAllowThreads();
24316 result = (arg1)->GetLastMonthDay(arg2,arg3);
24317 wxPyEndAllowThreads(__tstate);
24318 if (PyErr_Occurred()) SWIG_fail;
24319 }
24320 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24321 return resultobj;
24322 fail:
24323 return NULL;
24324 }
24325
24326
24327 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24328 PyObject *resultobj = 0;
24329 wxDateTime *arg1 = (wxDateTime *) 0 ;
24330 int arg2 ;
24331 wxDateTime *result = 0 ;
24332 void *argp1 = 0 ;
24333 int res1 = 0 ;
24334 int val2 ;
24335 int ecode2 = 0 ;
24336 PyObject * obj0 = 0 ;
24337 PyObject * obj1 = 0 ;
24338 char * kwnames[] = {
24339 (char *) "self",(char *) "yday", NULL
24340 };
24341
24342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24344 if (!SWIG_IsOK(res1)) {
24345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24346 }
24347 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24348 ecode2 = SWIG_AsVal_int(obj1, &val2);
24349 if (!SWIG_IsOK(ecode2)) {
24350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24351 }
24352 arg2 = static_cast< int >(val2);
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 {
24356 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24357 result = (wxDateTime *) &_result_ref;
24358 }
24359 wxPyEndAllowThreads(__tstate);
24360 if (PyErr_Occurred()) SWIG_fail;
24361 }
24362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24370 PyObject *resultobj = 0;
24371 wxDateTime *arg1 = (wxDateTime *) 0 ;
24372 int arg2 ;
24373 wxDateTime result;
24374 void *argp1 = 0 ;
24375 int res1 = 0 ;
24376 int val2 ;
24377 int ecode2 = 0 ;
24378 PyObject * obj0 = 0 ;
24379 PyObject * obj1 = 0 ;
24380 char * kwnames[] = {
24381 (char *) "self",(char *) "yday", NULL
24382 };
24383
24384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24386 if (!SWIG_IsOK(res1)) {
24387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24388 }
24389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24390 ecode2 = SWIG_AsVal_int(obj1, &val2);
24391 if (!SWIG_IsOK(ecode2)) {
24392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24393 }
24394 arg2 = static_cast< int >(val2);
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 result = (arg1)->GetYearDay(arg2);
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24409 PyObject *resultobj = 0;
24410 wxDateTime *arg1 = (wxDateTime *) 0 ;
24411 double result;
24412 void *argp1 = 0 ;
24413 int res1 = 0 ;
24414 PyObject *swig_obj[1] ;
24415
24416 if (!args) SWIG_fail;
24417 swig_obj[0] = args;
24418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24419 if (!SWIG_IsOK(res1)) {
24420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24421 }
24422 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24423 {
24424 PyThreadState* __tstate = wxPyBeginAllowThreads();
24425 result = (double)(arg1)->GetJulianDayNumber();
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 resultobj = SWIG_From_double(static_cast< double >(result));
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24437 PyObject *resultobj = 0;
24438 wxDateTime *arg1 = (wxDateTime *) 0 ;
24439 double result;
24440 void *argp1 = 0 ;
24441 int res1 = 0 ;
24442 PyObject *swig_obj[1] ;
24443
24444 if (!args) SWIG_fail;
24445 swig_obj[0] = args;
24446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24447 if (!SWIG_IsOK(res1)) {
24448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24449 }
24450 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 result = (double)(arg1)->GetJDN();
24454 wxPyEndAllowThreads(__tstate);
24455 if (PyErr_Occurred()) SWIG_fail;
24456 }
24457 resultobj = SWIG_From_double(static_cast< double >(result));
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24465 PyObject *resultobj = 0;
24466 wxDateTime *arg1 = (wxDateTime *) 0 ;
24467 double result;
24468 void *argp1 = 0 ;
24469 int res1 = 0 ;
24470 PyObject *swig_obj[1] ;
24471
24472 if (!args) SWIG_fail;
24473 swig_obj[0] = args;
24474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24475 if (!SWIG_IsOK(res1)) {
24476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24477 }
24478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24479 {
24480 PyThreadState* __tstate = wxPyBeginAllowThreads();
24481 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24482 wxPyEndAllowThreads(__tstate);
24483 if (PyErr_Occurred()) SWIG_fail;
24484 }
24485 resultobj = SWIG_From_double(static_cast< double >(result));
24486 return resultobj;
24487 fail:
24488 return NULL;
24489 }
24490
24491
24492 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24493 PyObject *resultobj = 0;
24494 wxDateTime *arg1 = (wxDateTime *) 0 ;
24495 double result;
24496 void *argp1 = 0 ;
24497 int res1 = 0 ;
24498 PyObject *swig_obj[1] ;
24499
24500 if (!args) SWIG_fail;
24501 swig_obj[0] = args;
24502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24503 if (!SWIG_IsOK(res1)) {
24504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24505 }
24506 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 result = (double)(arg1)->GetMJD();
24510 wxPyEndAllowThreads(__tstate);
24511 if (PyErr_Occurred()) SWIG_fail;
24512 }
24513 resultobj = SWIG_From_double(static_cast< double >(result));
24514 return resultobj;
24515 fail:
24516 return NULL;
24517 }
24518
24519
24520 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24521 PyObject *resultobj = 0;
24522 wxDateTime *arg1 = (wxDateTime *) 0 ;
24523 double result;
24524 void *argp1 = 0 ;
24525 int res1 = 0 ;
24526 PyObject *swig_obj[1] ;
24527
24528 if (!args) SWIG_fail;
24529 swig_obj[0] = args;
24530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24531 if (!SWIG_IsOK(res1)) {
24532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24533 }
24534 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24535 {
24536 PyThreadState* __tstate = wxPyBeginAllowThreads();
24537 result = (double)(arg1)->GetRataDie();
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 resultobj = SWIG_From_double(static_cast< double >(result));
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj = 0;
24550 wxDateTime *arg1 = (wxDateTime *) 0 ;
24551 wxDateTime::TimeZone *arg2 = 0 ;
24552 bool arg3 = (bool) false ;
24553 wxDateTime result;
24554 void *argp1 = 0 ;
24555 int res1 = 0 ;
24556 bool temp2 = false ;
24557 bool val3 ;
24558 int ecode3 = 0 ;
24559 PyObject * obj0 = 0 ;
24560 PyObject * obj1 = 0 ;
24561 PyObject * obj2 = 0 ;
24562 char * kwnames[] = {
24563 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24564 };
24565
24566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24568 if (!SWIG_IsOK(res1)) {
24569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24570 }
24571 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24572 {
24573 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24574 temp2 = true;
24575 }
24576 if (obj2) {
24577 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24578 if (!SWIG_IsOK(ecode3)) {
24579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24580 }
24581 arg3 = static_cast< bool >(val3);
24582 }
24583 {
24584 PyThreadState* __tstate = wxPyBeginAllowThreads();
24585 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24586 wxPyEndAllowThreads(__tstate);
24587 if (PyErr_Occurred()) SWIG_fail;
24588 }
24589 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24590 {
24591 if (temp2) delete arg2;
24592 }
24593 return resultobj;
24594 fail:
24595 {
24596 if (temp2) delete arg2;
24597 }
24598 return NULL;
24599 }
24600
24601
24602 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24603 PyObject *resultobj = 0;
24604 wxDateTime *arg1 = (wxDateTime *) 0 ;
24605 wxDateTime::TimeZone *arg2 = 0 ;
24606 bool arg3 = (bool) false ;
24607 wxDateTime *result = 0 ;
24608 void *argp1 = 0 ;
24609 int res1 = 0 ;
24610 bool temp2 = false ;
24611 bool val3 ;
24612 int ecode3 = 0 ;
24613 PyObject * obj0 = 0 ;
24614 PyObject * obj1 = 0 ;
24615 PyObject * obj2 = 0 ;
24616 char * kwnames[] = {
24617 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24618 };
24619
24620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24622 if (!SWIG_IsOK(res1)) {
24623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24624 }
24625 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24626 {
24627 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24628 temp2 = true;
24629 }
24630 if (obj2) {
24631 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24632 if (!SWIG_IsOK(ecode3)) {
24633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24634 }
24635 arg3 = static_cast< bool >(val3);
24636 }
24637 {
24638 PyThreadState* __tstate = wxPyBeginAllowThreads();
24639 {
24640 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24641 result = (wxDateTime *) &_result_ref;
24642 }
24643 wxPyEndAllowThreads(__tstate);
24644 if (PyErr_Occurred()) SWIG_fail;
24645 }
24646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24647 {
24648 if (temp2) delete arg2;
24649 }
24650 return resultobj;
24651 fail:
24652 {
24653 if (temp2) delete arg2;
24654 }
24655 return NULL;
24656 }
24657
24658
24659 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24660 PyObject *resultobj = 0;
24661 wxDateTime *arg1 = (wxDateTime *) 0 ;
24662 wxDateTime::TimeZone *arg2 = 0 ;
24663 bool arg3 = (bool) false ;
24664 wxDateTime result;
24665 void *argp1 = 0 ;
24666 int res1 = 0 ;
24667 bool temp2 = false ;
24668 bool val3 ;
24669 int ecode3 = 0 ;
24670 PyObject * obj0 = 0 ;
24671 PyObject * obj1 = 0 ;
24672 PyObject * obj2 = 0 ;
24673 char * kwnames[] = {
24674 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24675 };
24676
24677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24679 if (!SWIG_IsOK(res1)) {
24680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24681 }
24682 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24683 {
24684 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24685 temp2 = true;
24686 }
24687 if (obj2) {
24688 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24689 if (!SWIG_IsOK(ecode3)) {
24690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24691 }
24692 arg3 = static_cast< bool >(val3);
24693 }
24694 {
24695 PyThreadState* __tstate = wxPyBeginAllowThreads();
24696 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24701 {
24702 if (temp2) delete arg2;
24703 }
24704 return resultobj;
24705 fail:
24706 {
24707 if (temp2) delete arg2;
24708 }
24709 return NULL;
24710 }
24711
24712
24713 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24714 PyObject *resultobj = 0;
24715 wxDateTime *arg1 = (wxDateTime *) 0 ;
24716 wxDateTime::TimeZone *arg2 = 0 ;
24717 bool arg3 = (bool) false ;
24718 wxDateTime *result = 0 ;
24719 void *argp1 = 0 ;
24720 int res1 = 0 ;
24721 bool temp2 = false ;
24722 bool val3 ;
24723 int ecode3 = 0 ;
24724 PyObject * obj0 = 0 ;
24725 PyObject * obj1 = 0 ;
24726 PyObject * obj2 = 0 ;
24727 char * kwnames[] = {
24728 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24729 };
24730
24731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24733 if (!SWIG_IsOK(res1)) {
24734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24735 }
24736 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24737 {
24738 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24739 temp2 = true;
24740 }
24741 if (obj2) {
24742 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24743 if (!SWIG_IsOK(ecode3)) {
24744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24745 }
24746 arg3 = static_cast< bool >(val3);
24747 }
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 {
24751 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24752 result = (wxDateTime *) &_result_ref;
24753 }
24754 wxPyEndAllowThreads(__tstate);
24755 if (PyErr_Occurred()) SWIG_fail;
24756 }
24757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24758 {
24759 if (temp2) delete arg2;
24760 }
24761 return resultobj;
24762 fail:
24763 {
24764 if (temp2) delete arg2;
24765 }
24766 return NULL;
24767 }
24768
24769
24770 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24771 PyObject *resultobj = 0;
24772 wxDateTime *arg1 = (wxDateTime *) 0 ;
24773 bool arg2 = (bool) false ;
24774 wxDateTime result;
24775 void *argp1 = 0 ;
24776 int res1 = 0 ;
24777 bool val2 ;
24778 int ecode2 = 0 ;
24779 PyObject * obj0 = 0 ;
24780 PyObject * obj1 = 0 ;
24781 char * kwnames[] = {
24782 (char *) "self",(char *) "noDST", NULL
24783 };
24784
24785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24787 if (!SWIG_IsOK(res1)) {
24788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24789 }
24790 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24791 if (obj1) {
24792 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24793 if (!SWIG_IsOK(ecode2)) {
24794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24795 }
24796 arg2 = static_cast< bool >(val2);
24797 }
24798 {
24799 PyThreadState* __tstate = wxPyBeginAllowThreads();
24800 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24801 wxPyEndAllowThreads(__tstate);
24802 if (PyErr_Occurred()) SWIG_fail;
24803 }
24804 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24805 return resultobj;
24806 fail:
24807 return NULL;
24808 }
24809
24810
24811 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24812 PyObject *resultobj = 0;
24813 wxDateTime *arg1 = (wxDateTime *) 0 ;
24814 bool arg2 = (bool) false ;
24815 wxDateTime *result = 0 ;
24816 void *argp1 = 0 ;
24817 int res1 = 0 ;
24818 bool val2 ;
24819 int ecode2 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 PyObject * obj1 = 0 ;
24822 char * kwnames[] = {
24823 (char *) "self",(char *) "noDST", NULL
24824 };
24825
24826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24828 if (!SWIG_IsOK(res1)) {
24829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24830 }
24831 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24832 if (obj1) {
24833 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24834 if (!SWIG_IsOK(ecode2)) {
24835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24836 }
24837 arg2 = static_cast< bool >(val2);
24838 }
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 {
24842 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24843 result = (wxDateTime *) &_result_ref;
24844 }
24845 wxPyEndAllowThreads(__tstate);
24846 if (PyErr_Occurred()) SWIG_fail;
24847 }
24848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24849 return resultobj;
24850 fail:
24851 return NULL;
24852 }
24853
24854
24855 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24856 PyObject *resultobj = 0;
24857 wxDateTime *arg1 = (wxDateTime *) 0 ;
24858 bool arg2 = (bool) false ;
24859 wxDateTime result;
24860 void *argp1 = 0 ;
24861 int res1 = 0 ;
24862 bool val2 ;
24863 int ecode2 = 0 ;
24864 PyObject * obj0 = 0 ;
24865 PyObject * obj1 = 0 ;
24866 char * kwnames[] = {
24867 (char *) "self",(char *) "noDST", NULL
24868 };
24869
24870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24872 if (!SWIG_IsOK(res1)) {
24873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24874 }
24875 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24876 if (obj1) {
24877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24878 if (!SWIG_IsOK(ecode2)) {
24879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24880 }
24881 arg2 = static_cast< bool >(val2);
24882 }
24883 {
24884 PyThreadState* __tstate = wxPyBeginAllowThreads();
24885 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24886 wxPyEndAllowThreads(__tstate);
24887 if (PyErr_Occurred()) SWIG_fail;
24888 }
24889 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24890 return resultobj;
24891 fail:
24892 return NULL;
24893 }
24894
24895
24896 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24897 PyObject *resultobj = 0;
24898 wxDateTime *arg1 = (wxDateTime *) 0 ;
24899 bool arg2 = (bool) false ;
24900 wxDateTime *result = 0 ;
24901 void *argp1 = 0 ;
24902 int res1 = 0 ;
24903 bool val2 ;
24904 int ecode2 = 0 ;
24905 PyObject * obj0 = 0 ;
24906 PyObject * obj1 = 0 ;
24907 char * kwnames[] = {
24908 (char *) "self",(char *) "noDST", NULL
24909 };
24910
24911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24913 if (!SWIG_IsOK(res1)) {
24914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24915 }
24916 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24917 if (obj1) {
24918 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24919 if (!SWIG_IsOK(ecode2)) {
24920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24921 }
24922 arg2 = static_cast< bool >(val2);
24923 }
24924 {
24925 PyThreadState* __tstate = wxPyBeginAllowThreads();
24926 {
24927 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24928 result = (wxDateTime *) &_result_ref;
24929 }
24930 wxPyEndAllowThreads(__tstate);
24931 if (PyErr_Occurred()) SWIG_fail;
24932 }
24933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24941 PyObject *resultobj = 0;
24942 wxDateTime *arg1 = (wxDateTime *) 0 ;
24943 bool arg2 = (bool) false ;
24944 wxDateTime result;
24945 void *argp1 = 0 ;
24946 int res1 = 0 ;
24947 bool val2 ;
24948 int ecode2 = 0 ;
24949 PyObject * obj0 = 0 ;
24950 PyObject * obj1 = 0 ;
24951 char * kwnames[] = {
24952 (char *) "self",(char *) "noDST", NULL
24953 };
24954
24955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24957 if (!SWIG_IsOK(res1)) {
24958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24959 }
24960 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24961 if (obj1) {
24962 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24963 if (!SWIG_IsOK(ecode2)) {
24964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24965 }
24966 arg2 = static_cast< bool >(val2);
24967 }
24968 {
24969 PyThreadState* __tstate = wxPyBeginAllowThreads();
24970 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24971 wxPyEndAllowThreads(__tstate);
24972 if (PyErr_Occurred()) SWIG_fail;
24973 }
24974 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24982 PyObject *resultobj = 0;
24983 wxDateTime *arg1 = (wxDateTime *) 0 ;
24984 bool arg2 = (bool) false ;
24985 wxDateTime *result = 0 ;
24986 void *argp1 = 0 ;
24987 int res1 = 0 ;
24988 bool val2 ;
24989 int ecode2 = 0 ;
24990 PyObject * obj0 = 0 ;
24991 PyObject * obj1 = 0 ;
24992 char * kwnames[] = {
24993 (char *) "self",(char *) "noDST", NULL
24994 };
24995
24996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24998 if (!SWIG_IsOK(res1)) {
24999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25000 }
25001 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25002 if (obj1) {
25003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25004 if (!SWIG_IsOK(ecode2)) {
25005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25006 }
25007 arg2 = static_cast< bool >(val2);
25008 }
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 {
25012 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25013 result = (wxDateTime *) &_result_ref;
25014 }
25015 wxPyEndAllowThreads(__tstate);
25016 if (PyErr_Occurred()) SWIG_fail;
25017 }
25018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25019 return resultobj;
25020 fail:
25021 return NULL;
25022 }
25023
25024
25025 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25026 PyObject *resultobj = 0;
25027 wxDateTime *arg1 = (wxDateTime *) 0 ;
25028 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25029 int result;
25030 void *argp1 = 0 ;
25031 int res1 = 0 ;
25032 int val2 ;
25033 int ecode2 = 0 ;
25034 PyObject * obj0 = 0 ;
25035 PyObject * obj1 = 0 ;
25036 char * kwnames[] = {
25037 (char *) "self",(char *) "country", NULL
25038 };
25039
25040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25042 if (!SWIG_IsOK(res1)) {
25043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
25044 }
25045 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25046 if (obj1) {
25047 ecode2 = SWIG_AsVal_int(obj1, &val2);
25048 if (!SWIG_IsOK(ecode2)) {
25049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25050 }
25051 arg2 = static_cast< wxDateTime::Country >(val2);
25052 }
25053 {
25054 PyThreadState* __tstate = wxPyBeginAllowThreads();
25055 result = (int)(arg1)->IsDST(arg2);
25056 wxPyEndAllowThreads(__tstate);
25057 if (PyErr_Occurred()) SWIG_fail;
25058 }
25059 resultobj = SWIG_From_int(static_cast< int >(result));
25060 return resultobj;
25061 fail:
25062 return NULL;
25063 }
25064
25065
25066 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25067 PyObject *resultobj = 0;
25068 wxDateTime *arg1 = (wxDateTime *) 0 ;
25069 bool result;
25070 void *argp1 = 0 ;
25071 int res1 = 0 ;
25072 PyObject *swig_obj[1] ;
25073
25074 if (!args) SWIG_fail;
25075 swig_obj[0] = args;
25076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25077 if (!SWIG_IsOK(res1)) {
25078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25079 }
25080 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25081 {
25082 PyThreadState* __tstate = wxPyBeginAllowThreads();
25083 result = (bool)((wxDateTime const *)arg1)->IsValid();
25084 wxPyEndAllowThreads(__tstate);
25085 if (PyErr_Occurred()) SWIG_fail;
25086 }
25087 {
25088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25089 }
25090 return resultobj;
25091 fail:
25092 return NULL;
25093 }
25094
25095
25096 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25097 PyObject *resultobj = 0;
25098 wxDateTime *arg1 = (wxDateTime *) 0 ;
25099 time_t result;
25100 void *argp1 = 0 ;
25101 int res1 = 0 ;
25102 PyObject *swig_obj[1] ;
25103
25104 if (!args) SWIG_fail;
25105 swig_obj[0] = args;
25106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25107 if (!SWIG_IsOK(res1)) {
25108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25109 }
25110 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
25114 wxPyEndAllowThreads(__tstate);
25115 if (PyErr_Occurred()) SWIG_fail;
25116 }
25117 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25118 return resultobj;
25119 fail:
25120 return NULL;
25121 }
25122
25123
25124 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25125 PyObject *resultobj = 0;
25126 wxDateTime *arg1 = (wxDateTime *) 0 ;
25127 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25128 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25129 int result;
25130 void *argp1 = 0 ;
25131 int res1 = 0 ;
25132 bool temp2 = false ;
25133 PyObject * obj0 = 0 ;
25134 PyObject * obj1 = 0 ;
25135 char * kwnames[] = {
25136 (char *) "self",(char *) "tz", NULL
25137 };
25138
25139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
25140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25141 if (!SWIG_IsOK(res1)) {
25142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25143 }
25144 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25145 if (obj1) {
25146 {
25147 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25148 temp2 = true;
25149 }
25150 }
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 resultobj = SWIG_From_int(static_cast< int >(result));
25158 {
25159 if (temp2) delete arg2;
25160 }
25161 return resultobj;
25162 fail:
25163 {
25164 if (temp2) delete arg2;
25165 }
25166 return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj = 0;
25172 wxDateTime *arg1 = (wxDateTime *) 0 ;
25173 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25174 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25175 wxDateTime::Month result;
25176 void *argp1 = 0 ;
25177 int res1 = 0 ;
25178 bool temp2 = false ;
25179 PyObject * obj0 = 0 ;
25180 PyObject * obj1 = 0 ;
25181 char * kwnames[] = {
25182 (char *) "self",(char *) "tz", NULL
25183 };
25184
25185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25187 if (!SWIG_IsOK(res1)) {
25188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25189 }
25190 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25191 if (obj1) {
25192 {
25193 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25194 temp2 = true;
25195 }
25196 }
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_From_int(static_cast< int >(result));
25204 {
25205 if (temp2) delete arg2;
25206 }
25207 return resultobj;
25208 fail:
25209 {
25210 if (temp2) delete arg2;
25211 }
25212 return NULL;
25213 }
25214
25215
25216 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25217 PyObject *resultobj = 0;
25218 wxDateTime *arg1 = (wxDateTime *) 0 ;
25219 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25220 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25221 int result;
25222 void *argp1 = 0 ;
25223 int res1 = 0 ;
25224 bool temp2 = false ;
25225 PyObject * obj0 = 0 ;
25226 PyObject * obj1 = 0 ;
25227 char * kwnames[] = {
25228 (char *) "self",(char *) "tz", NULL
25229 };
25230
25231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25233 if (!SWIG_IsOK(res1)) {
25234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25235 }
25236 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25237 if (obj1) {
25238 {
25239 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25240 temp2 = true;
25241 }
25242 }
25243 {
25244 PyThreadState* __tstate = wxPyBeginAllowThreads();
25245 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25246 wxPyEndAllowThreads(__tstate);
25247 if (PyErr_Occurred()) SWIG_fail;
25248 }
25249 resultobj = SWIG_From_int(static_cast< int >(result));
25250 {
25251 if (temp2) delete arg2;
25252 }
25253 return resultobj;
25254 fail:
25255 {
25256 if (temp2) delete arg2;
25257 }
25258 return NULL;
25259 }
25260
25261
25262 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25263 PyObject *resultobj = 0;
25264 wxDateTime *arg1 = (wxDateTime *) 0 ;
25265 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25266 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25267 wxDateTime::WeekDay result;
25268 void *argp1 = 0 ;
25269 int res1 = 0 ;
25270 bool temp2 = false ;
25271 PyObject * obj0 = 0 ;
25272 PyObject * obj1 = 0 ;
25273 char * kwnames[] = {
25274 (char *) "self",(char *) "tz", NULL
25275 };
25276
25277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25279 if (!SWIG_IsOK(res1)) {
25280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25281 }
25282 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25283 if (obj1) {
25284 {
25285 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25286 temp2 = true;
25287 }
25288 }
25289 {
25290 PyThreadState* __tstate = wxPyBeginAllowThreads();
25291 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25292 wxPyEndAllowThreads(__tstate);
25293 if (PyErr_Occurred()) SWIG_fail;
25294 }
25295 resultobj = SWIG_From_int(static_cast< int >(result));
25296 {
25297 if (temp2) delete arg2;
25298 }
25299 return resultobj;
25300 fail:
25301 {
25302 if (temp2) delete arg2;
25303 }
25304 return NULL;
25305 }
25306
25307
25308 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25309 PyObject *resultobj = 0;
25310 wxDateTime *arg1 = (wxDateTime *) 0 ;
25311 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25312 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25313 int result;
25314 void *argp1 = 0 ;
25315 int res1 = 0 ;
25316 bool temp2 = false ;
25317 PyObject * obj0 = 0 ;
25318 PyObject * obj1 = 0 ;
25319 char * kwnames[] = {
25320 (char *) "self",(char *) "tz", NULL
25321 };
25322
25323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25325 if (!SWIG_IsOK(res1)) {
25326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25327 }
25328 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25329 if (obj1) {
25330 {
25331 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25332 temp2 = true;
25333 }
25334 }
25335 {
25336 PyThreadState* __tstate = wxPyBeginAllowThreads();
25337 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25338 wxPyEndAllowThreads(__tstate);
25339 if (PyErr_Occurred()) SWIG_fail;
25340 }
25341 resultobj = SWIG_From_int(static_cast< int >(result));
25342 {
25343 if (temp2) delete arg2;
25344 }
25345 return resultobj;
25346 fail:
25347 {
25348 if (temp2) delete arg2;
25349 }
25350 return NULL;
25351 }
25352
25353
25354 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25355 PyObject *resultobj = 0;
25356 wxDateTime *arg1 = (wxDateTime *) 0 ;
25357 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25358 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25359 int result;
25360 void *argp1 = 0 ;
25361 int res1 = 0 ;
25362 bool temp2 = false ;
25363 PyObject * obj0 = 0 ;
25364 PyObject * obj1 = 0 ;
25365 char * kwnames[] = {
25366 (char *) "self",(char *) "tz", NULL
25367 };
25368
25369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25371 if (!SWIG_IsOK(res1)) {
25372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25373 }
25374 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25375 if (obj1) {
25376 {
25377 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25378 temp2 = true;
25379 }
25380 }
25381 {
25382 PyThreadState* __tstate = wxPyBeginAllowThreads();
25383 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25384 wxPyEndAllowThreads(__tstate);
25385 if (PyErr_Occurred()) SWIG_fail;
25386 }
25387 resultobj = SWIG_From_int(static_cast< int >(result));
25388 {
25389 if (temp2) delete arg2;
25390 }
25391 return resultobj;
25392 fail:
25393 {
25394 if (temp2) delete arg2;
25395 }
25396 return NULL;
25397 }
25398
25399
25400 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj = 0;
25402 wxDateTime *arg1 = (wxDateTime *) 0 ;
25403 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25404 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25405 int result;
25406 void *argp1 = 0 ;
25407 int res1 = 0 ;
25408 bool temp2 = false ;
25409 PyObject * obj0 = 0 ;
25410 PyObject * obj1 = 0 ;
25411 char * kwnames[] = {
25412 (char *) "self",(char *) "tz", NULL
25413 };
25414
25415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25417 if (!SWIG_IsOK(res1)) {
25418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25419 }
25420 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25421 if (obj1) {
25422 {
25423 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25424 temp2 = true;
25425 }
25426 }
25427 {
25428 PyThreadState* __tstate = wxPyBeginAllowThreads();
25429 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25430 wxPyEndAllowThreads(__tstate);
25431 if (PyErr_Occurred()) SWIG_fail;
25432 }
25433 resultobj = SWIG_From_int(static_cast< int >(result));
25434 {
25435 if (temp2) delete arg2;
25436 }
25437 return resultobj;
25438 fail:
25439 {
25440 if (temp2) delete arg2;
25441 }
25442 return NULL;
25443 }
25444
25445
25446 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25447 PyObject *resultobj = 0;
25448 wxDateTime *arg1 = (wxDateTime *) 0 ;
25449 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25450 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25451 int result;
25452 void *argp1 = 0 ;
25453 int res1 = 0 ;
25454 bool temp2 = false ;
25455 PyObject * obj0 = 0 ;
25456 PyObject * obj1 = 0 ;
25457 char * kwnames[] = {
25458 (char *) "self",(char *) "tz", NULL
25459 };
25460
25461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25463 if (!SWIG_IsOK(res1)) {
25464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25465 }
25466 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25467 if (obj1) {
25468 {
25469 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25470 temp2 = true;
25471 }
25472 }
25473 {
25474 PyThreadState* __tstate = wxPyBeginAllowThreads();
25475 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25476 wxPyEndAllowThreads(__tstate);
25477 if (PyErr_Occurred()) SWIG_fail;
25478 }
25479 resultobj = SWIG_From_int(static_cast< int >(result));
25480 {
25481 if (temp2) delete arg2;
25482 }
25483 return resultobj;
25484 fail:
25485 {
25486 if (temp2) delete arg2;
25487 }
25488 return NULL;
25489 }
25490
25491
25492 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25493 PyObject *resultobj = 0;
25494 wxDateTime *arg1 = (wxDateTime *) 0 ;
25495 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25496 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25497 int result;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 bool temp2 = false ;
25501 PyObject * obj0 = 0 ;
25502 PyObject * obj1 = 0 ;
25503 char * kwnames[] = {
25504 (char *) "self",(char *) "tz", NULL
25505 };
25506
25507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25509 if (!SWIG_IsOK(res1)) {
25510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25511 }
25512 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25513 if (obj1) {
25514 {
25515 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25516 temp2 = true;
25517 }
25518 }
25519 {
25520 PyThreadState* __tstate = wxPyBeginAllowThreads();
25521 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25522 wxPyEndAllowThreads(__tstate);
25523 if (PyErr_Occurred()) SWIG_fail;
25524 }
25525 resultobj = SWIG_From_int(static_cast< int >(result));
25526 {
25527 if (temp2) delete arg2;
25528 }
25529 return resultobj;
25530 fail:
25531 {
25532 if (temp2) delete arg2;
25533 }
25534 return NULL;
25535 }
25536
25537
25538 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25539 PyObject *resultobj = 0;
25540 wxDateTime *arg1 = (wxDateTime *) 0 ;
25541 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25542 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25543 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25544 int result;
25545 void *argp1 = 0 ;
25546 int res1 = 0 ;
25547 int val2 ;
25548 int ecode2 = 0 ;
25549 bool temp3 = false ;
25550 PyObject * obj0 = 0 ;
25551 PyObject * obj1 = 0 ;
25552 PyObject * obj2 = 0 ;
25553 char * kwnames[] = {
25554 (char *) "self",(char *) "flags",(char *) "tz", NULL
25555 };
25556
25557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25559 if (!SWIG_IsOK(res1)) {
25560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25561 }
25562 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25563 if (obj1) {
25564 ecode2 = SWIG_AsVal_int(obj1, &val2);
25565 if (!SWIG_IsOK(ecode2)) {
25566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25567 }
25568 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25569 }
25570 if (obj2) {
25571 {
25572 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25573 temp3 = true;
25574 }
25575 }
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_From_int(static_cast< int >(result));
25583 {
25584 if (temp3) delete arg3;
25585 }
25586 return resultobj;
25587 fail:
25588 {
25589 if (temp3) delete arg3;
25590 }
25591 return NULL;
25592 }
25593
25594
25595 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25596 PyObject *resultobj = 0;
25597 wxDateTime *arg1 = (wxDateTime *) 0 ;
25598 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25599 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25600 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25601 int result;
25602 void *argp1 = 0 ;
25603 int res1 = 0 ;
25604 int val2 ;
25605 int ecode2 = 0 ;
25606 bool temp3 = false ;
25607 PyObject * obj0 = 0 ;
25608 PyObject * obj1 = 0 ;
25609 PyObject * obj2 = 0 ;
25610 char * kwnames[] = {
25611 (char *) "self",(char *) "flags",(char *) "tz", NULL
25612 };
25613
25614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25618 }
25619 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25620 if (obj1) {
25621 ecode2 = SWIG_AsVal_int(obj1, &val2);
25622 if (!SWIG_IsOK(ecode2)) {
25623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25624 }
25625 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25626 }
25627 if (obj2) {
25628 {
25629 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25630 temp3 = true;
25631 }
25632 }
25633 {
25634 PyThreadState* __tstate = wxPyBeginAllowThreads();
25635 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25636 wxPyEndAllowThreads(__tstate);
25637 if (PyErr_Occurred()) SWIG_fail;
25638 }
25639 resultobj = SWIG_From_int(static_cast< int >(result));
25640 {
25641 if (temp3) delete arg3;
25642 }
25643 return resultobj;
25644 fail:
25645 {
25646 if (temp3) delete arg3;
25647 }
25648 return NULL;
25649 }
25650
25651
25652 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25653 PyObject *resultobj = 0;
25654 wxDateTime *arg1 = (wxDateTime *) 0 ;
25655 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25656 bool result;
25657 void *argp1 = 0 ;
25658 int res1 = 0 ;
25659 int val2 ;
25660 int ecode2 = 0 ;
25661 PyObject * obj0 = 0 ;
25662 PyObject * obj1 = 0 ;
25663 char * kwnames[] = {
25664 (char *) "self",(char *) "country", NULL
25665 };
25666
25667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25669 if (!SWIG_IsOK(res1)) {
25670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25671 }
25672 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25673 if (obj1) {
25674 ecode2 = SWIG_AsVal_int(obj1, &val2);
25675 if (!SWIG_IsOK(ecode2)) {
25676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25677 }
25678 arg2 = static_cast< wxDateTime::Country >(val2);
25679 }
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25683 wxPyEndAllowThreads(__tstate);
25684 if (PyErr_Occurred()) SWIG_fail;
25685 }
25686 {
25687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25688 }
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25696 PyObject *resultobj = 0;
25697 wxDateTime *arg1 = (wxDateTime *) 0 ;
25698 wxDateTime *arg2 = 0 ;
25699 bool result;
25700 void *argp1 = 0 ;
25701 int res1 = 0 ;
25702 void *argp2 = 0 ;
25703 int res2 = 0 ;
25704 PyObject * obj0 = 0 ;
25705 PyObject * obj1 = 0 ;
25706 char * kwnames[] = {
25707 (char *) "self",(char *) "datetime", NULL
25708 };
25709
25710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25712 if (!SWIG_IsOK(res1)) {
25713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25714 }
25715 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25716 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25717 if (!SWIG_IsOK(res2)) {
25718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25719 }
25720 if (!argp2) {
25721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25722 }
25723 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25724 {
25725 PyThreadState* __tstate = wxPyBeginAllowThreads();
25726 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 {
25731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25732 }
25733 return resultobj;
25734 fail:
25735 return NULL;
25736 }
25737
25738
25739 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25740 PyObject *resultobj = 0;
25741 wxDateTime *arg1 = (wxDateTime *) 0 ;
25742 wxDateTime *arg2 = 0 ;
25743 bool result;
25744 void *argp1 = 0 ;
25745 int res1 = 0 ;
25746 void *argp2 = 0 ;
25747 int res2 = 0 ;
25748 PyObject * obj0 = 0 ;
25749 PyObject * obj1 = 0 ;
25750 char * kwnames[] = {
25751 (char *) "self",(char *) "datetime", NULL
25752 };
25753
25754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25756 if (!SWIG_IsOK(res1)) {
25757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25758 }
25759 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25761 if (!SWIG_IsOK(res2)) {
25762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25763 }
25764 if (!argp2) {
25765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25766 }
25767 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 {
25775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25776 }
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25784 PyObject *resultobj = 0;
25785 wxDateTime *arg1 = (wxDateTime *) 0 ;
25786 wxDateTime *arg2 = 0 ;
25787 bool result;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 void *argp2 = 0 ;
25791 int res2 = 0 ;
25792 PyObject * obj0 = 0 ;
25793 PyObject * obj1 = 0 ;
25794 char * kwnames[] = {
25795 (char *) "self",(char *) "datetime", NULL
25796 };
25797
25798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25800 if (!SWIG_IsOK(res1)) {
25801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25802 }
25803 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25804 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25805 if (!SWIG_IsOK(res2)) {
25806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25807 }
25808 if (!argp2) {
25809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25810 }
25811 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 {
25819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25820 }
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = 0;
25829 wxDateTime *arg1 = (wxDateTime *) 0 ;
25830 wxDateTime *arg2 = 0 ;
25831 wxDateTime *arg3 = 0 ;
25832 bool result;
25833 void *argp1 = 0 ;
25834 int res1 = 0 ;
25835 void *argp2 = 0 ;
25836 int res2 = 0 ;
25837 void *argp3 = 0 ;
25838 int res3 = 0 ;
25839 PyObject * obj0 = 0 ;
25840 PyObject * obj1 = 0 ;
25841 PyObject * obj2 = 0 ;
25842 char * kwnames[] = {
25843 (char *) "self",(char *) "t1",(char *) "t2", NULL
25844 };
25845
25846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25848 if (!SWIG_IsOK(res1)) {
25849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25850 }
25851 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25852 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25853 if (!SWIG_IsOK(res2)) {
25854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25855 }
25856 if (!argp2) {
25857 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25858 }
25859 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25860 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25861 if (!SWIG_IsOK(res3)) {
25862 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25863 }
25864 if (!argp3) {
25865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25866 }
25867 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25868 {
25869 PyThreadState* __tstate = wxPyBeginAllowThreads();
25870 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 {
25875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25876 }
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25884 PyObject *resultobj = 0;
25885 wxDateTime *arg1 = (wxDateTime *) 0 ;
25886 wxDateTime *arg2 = 0 ;
25887 wxDateTime *arg3 = 0 ;
25888 bool result;
25889 void *argp1 = 0 ;
25890 int res1 = 0 ;
25891 void *argp2 = 0 ;
25892 int res2 = 0 ;
25893 void *argp3 = 0 ;
25894 int res3 = 0 ;
25895 PyObject * obj0 = 0 ;
25896 PyObject * obj1 = 0 ;
25897 PyObject * obj2 = 0 ;
25898 char * kwnames[] = {
25899 (char *) "self",(char *) "t1",(char *) "t2", NULL
25900 };
25901
25902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25904 if (!SWIG_IsOK(res1)) {
25905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25906 }
25907 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25908 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25909 if (!SWIG_IsOK(res2)) {
25910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25911 }
25912 if (!argp2) {
25913 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25914 }
25915 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25916 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25917 if (!SWIG_IsOK(res3)) {
25918 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25919 }
25920 if (!argp3) {
25921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25922 }
25923 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25927 wxPyEndAllowThreads(__tstate);
25928 if (PyErr_Occurred()) SWIG_fail;
25929 }
25930 {
25931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25932 }
25933 return resultobj;
25934 fail:
25935 return NULL;
25936 }
25937
25938
25939 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25940 PyObject *resultobj = 0;
25941 wxDateTime *arg1 = (wxDateTime *) 0 ;
25942 wxDateTime *arg2 = 0 ;
25943 bool result;
25944 void *argp1 = 0 ;
25945 int res1 = 0 ;
25946 void *argp2 = 0 ;
25947 int res2 = 0 ;
25948 PyObject * obj0 = 0 ;
25949 PyObject * obj1 = 0 ;
25950 char * kwnames[] = {
25951 (char *) "self",(char *) "dt", NULL
25952 };
25953
25954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25956 if (!SWIG_IsOK(res1)) {
25957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25958 }
25959 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25961 if (!SWIG_IsOK(res2)) {
25962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25963 }
25964 if (!argp2) {
25965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25966 }
25967 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25968 {
25969 PyThreadState* __tstate = wxPyBeginAllowThreads();
25970 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25971 wxPyEndAllowThreads(__tstate);
25972 if (PyErr_Occurred()) SWIG_fail;
25973 }
25974 {
25975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25976 }
25977 return resultobj;
25978 fail:
25979 return NULL;
25980 }
25981
25982
25983 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25984 PyObject *resultobj = 0;
25985 wxDateTime *arg1 = (wxDateTime *) 0 ;
25986 wxDateTime *arg2 = 0 ;
25987 bool result;
25988 void *argp1 = 0 ;
25989 int res1 = 0 ;
25990 void *argp2 = 0 ;
25991 int res2 = 0 ;
25992 PyObject * obj0 = 0 ;
25993 PyObject * obj1 = 0 ;
25994 char * kwnames[] = {
25995 (char *) "self",(char *) "dt", NULL
25996 };
25997
25998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26002 }
26003 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26004 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26005 if (!SWIG_IsOK(res2)) {
26006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26007 }
26008 if (!argp2) {
26009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26010 }
26011 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 {
26019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26020 }
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj = 0;
26029 wxDateTime *arg1 = (wxDateTime *) 0 ;
26030 wxDateTime *arg2 = 0 ;
26031 wxTimeSpan *arg3 = 0 ;
26032 bool result;
26033 void *argp1 = 0 ;
26034 int res1 = 0 ;
26035 void *argp2 = 0 ;
26036 int res2 = 0 ;
26037 void *argp3 = 0 ;
26038 int res3 = 0 ;
26039 PyObject * obj0 = 0 ;
26040 PyObject * obj1 = 0 ;
26041 PyObject * obj2 = 0 ;
26042 char * kwnames[] = {
26043 (char *) "self",(char *) "dt",(char *) "ts", NULL
26044 };
26045
26046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26048 if (!SWIG_IsOK(res1)) {
26049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26050 }
26051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26053 if (!SWIG_IsOK(res2)) {
26054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26055 }
26056 if (!argp2) {
26057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26058 }
26059 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26060 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26061 if (!SWIG_IsOK(res3)) {
26062 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26063 }
26064 if (!argp3) {
26065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26066 }
26067 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26068 {
26069 PyThreadState* __tstate = wxPyBeginAllowThreads();
26070 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26071 wxPyEndAllowThreads(__tstate);
26072 if (PyErr_Occurred()) SWIG_fail;
26073 }
26074 {
26075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26076 }
26077 return resultobj;
26078 fail:
26079 return NULL;
26080 }
26081
26082
26083 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26084 PyObject *resultobj = 0;
26085 wxDateTime *arg1 = (wxDateTime *) 0 ;
26086 wxTimeSpan *arg2 = 0 ;
26087 wxDateTime *result = 0 ;
26088 void *argp1 = 0 ;
26089 int res1 = 0 ;
26090 void *argp2 = 0 ;
26091 int res2 = 0 ;
26092 PyObject * obj0 = 0 ;
26093 PyObject * obj1 = 0 ;
26094 char * kwnames[] = {
26095 (char *) "self",(char *) "diff", NULL
26096 };
26097
26098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
26099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26100 if (!SWIG_IsOK(res1)) {
26101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26102 }
26103 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26104 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26105 if (!SWIG_IsOK(res2)) {
26106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26107 }
26108 if (!argp2) {
26109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26110 }
26111 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 {
26115 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
26116 result = (wxDateTime *) &_result_ref;
26117 }
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26129 PyObject *resultobj = 0;
26130 wxDateTime *arg1 = (wxDateTime *) 0 ;
26131 wxDateSpan *arg2 = 0 ;
26132 wxDateTime *result = 0 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 void *argp2 = 0 ;
26136 int res2 = 0 ;
26137 PyObject * obj0 = 0 ;
26138 PyObject * obj1 = 0 ;
26139 char * kwnames[] = {
26140 (char *) "self",(char *) "diff", NULL
26141 };
26142
26143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
26144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26145 if (!SWIG_IsOK(res1)) {
26146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26147 }
26148 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26149 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26150 if (!SWIG_IsOK(res2)) {
26151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26152 }
26153 if (!argp2) {
26154 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26155 }
26156 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26157 {
26158 PyThreadState* __tstate = wxPyBeginAllowThreads();
26159 {
26160 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26161 result = (wxDateTime *) &_result_ref;
26162 }
26163 wxPyEndAllowThreads(__tstate);
26164 if (PyErr_Occurred()) SWIG_fail;
26165 }
26166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26167 return resultobj;
26168 fail:
26169 return NULL;
26170 }
26171
26172
26173 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26174 PyObject *resultobj = 0;
26175 wxDateTime *arg1 = (wxDateTime *) 0 ;
26176 wxTimeSpan *arg2 = 0 ;
26177 wxDateTime *result = 0 ;
26178 void *argp1 = 0 ;
26179 int res1 = 0 ;
26180 void *argp2 = 0 ;
26181 int res2 = 0 ;
26182 PyObject * obj0 = 0 ;
26183 PyObject * obj1 = 0 ;
26184 char * kwnames[] = {
26185 (char *) "self",(char *) "diff", NULL
26186 };
26187
26188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26190 if (!SWIG_IsOK(res1)) {
26191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26192 }
26193 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26194 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26195 if (!SWIG_IsOK(res2)) {
26196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26197 }
26198 if (!argp2) {
26199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26200 }
26201 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26202 {
26203 PyThreadState* __tstate = wxPyBeginAllowThreads();
26204 {
26205 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26206 result = (wxDateTime *) &_result_ref;
26207 }
26208 wxPyEndAllowThreads(__tstate);
26209 if (PyErr_Occurred()) SWIG_fail;
26210 }
26211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26212 return resultobj;
26213 fail:
26214 return NULL;
26215 }
26216
26217
26218 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26219 PyObject *resultobj = 0;
26220 wxDateTime *arg1 = (wxDateTime *) 0 ;
26221 wxDateSpan *arg2 = 0 ;
26222 wxDateTime *result = 0 ;
26223 void *argp1 = 0 ;
26224 int res1 = 0 ;
26225 void *argp2 = 0 ;
26226 int res2 = 0 ;
26227 PyObject * obj0 = 0 ;
26228 PyObject * obj1 = 0 ;
26229 char * kwnames[] = {
26230 (char *) "self",(char *) "diff", NULL
26231 };
26232
26233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26235 if (!SWIG_IsOK(res1)) {
26236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26237 }
26238 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26239 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26240 if (!SWIG_IsOK(res2)) {
26241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26242 }
26243 if (!argp2) {
26244 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26245 }
26246 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26247 {
26248 PyThreadState* __tstate = wxPyBeginAllowThreads();
26249 {
26250 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26251 result = (wxDateTime *) &_result_ref;
26252 }
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26264 PyObject *resultobj = 0;
26265 wxDateTime *arg1 = (wxDateTime *) 0 ;
26266 wxDateTime *arg2 = 0 ;
26267 wxTimeSpan result;
26268 void *argp1 = 0 ;
26269 int res1 = 0 ;
26270 void *argp2 = 0 ;
26271 int res2 = 0 ;
26272 PyObject * obj0 = 0 ;
26273 PyObject * obj1 = 0 ;
26274 char * kwnames[] = {
26275 (char *) "self",(char *) "dt", NULL
26276 };
26277
26278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26280 if (!SWIG_IsOK(res1)) {
26281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26282 }
26283 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26284 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26285 if (!SWIG_IsOK(res2)) {
26286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26287 }
26288 if (!argp2) {
26289 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26290 }
26291 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26292 {
26293 PyThreadState* __tstate = wxPyBeginAllowThreads();
26294 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26306 PyObject *resultobj = 0;
26307 wxDateTime *arg1 = (wxDateTime *) 0 ;
26308 wxTimeSpan *arg2 = 0 ;
26309 wxDateTime *result = 0 ;
26310 void *argp1 = 0 ;
26311 int res1 = 0 ;
26312 void *argp2 = 0 ;
26313 int res2 = 0 ;
26314
26315 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26317 if (!SWIG_IsOK(res1)) {
26318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26319 }
26320 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26321 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26322 if (!SWIG_IsOK(res2)) {
26323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26324 }
26325 if (!argp2) {
26326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26327 }
26328 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26329 {
26330 PyThreadState* __tstate = wxPyBeginAllowThreads();
26331 {
26332 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26333 result = (wxDateTime *) &_result_ref;
26334 }
26335 wxPyEndAllowThreads(__tstate);
26336 if (PyErr_Occurred()) SWIG_fail;
26337 }
26338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26339 return resultobj;
26340 fail:
26341 return NULL;
26342 }
26343
26344
26345 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26346 PyObject *resultobj = 0;
26347 wxDateTime *arg1 = (wxDateTime *) 0 ;
26348 wxDateSpan *arg2 = 0 ;
26349 wxDateTime *result = 0 ;
26350 void *argp1 = 0 ;
26351 int res1 = 0 ;
26352 void *argp2 = 0 ;
26353 int res2 = 0 ;
26354
26355 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26357 if (!SWIG_IsOK(res1)) {
26358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26359 }
26360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26361 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26362 if (!SWIG_IsOK(res2)) {
26363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26364 }
26365 if (!argp2) {
26366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26367 }
26368 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26369 {
26370 PyThreadState* __tstate = wxPyBeginAllowThreads();
26371 {
26372 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26373 result = (wxDateTime *) &_result_ref;
26374 }
26375 wxPyEndAllowThreads(__tstate);
26376 if (PyErr_Occurred()) SWIG_fail;
26377 }
26378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26386 int argc;
26387 PyObject *argv[3];
26388
26389 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26390 --argc;
26391 if (argc == 2) {
26392 int _v = 0;
26393 {
26394 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26395 _v = SWIG_CheckState(res);
26396 }
26397 if (!_v) goto check_1;
26398 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26399 }
26400 check_1:
26401
26402 if (argc == 2) {
26403 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26404 }
26405
26406 fail:
26407 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26408 return NULL;
26409 }
26410
26411
26412 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26413 PyObject *resultobj = 0;
26414 wxDateTime *arg1 = (wxDateTime *) 0 ;
26415 wxTimeSpan *arg2 = 0 ;
26416 wxDateTime *result = 0 ;
26417 void *argp1 = 0 ;
26418 int res1 = 0 ;
26419 void *argp2 = 0 ;
26420 int res2 = 0 ;
26421
26422 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26424 if (!SWIG_IsOK(res1)) {
26425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26426 }
26427 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26428 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26429 if (!SWIG_IsOK(res2)) {
26430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26431 }
26432 if (!argp2) {
26433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26434 }
26435 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 {
26439 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26440 result = (wxDateTime *) &_result_ref;
26441 }
26442 wxPyEndAllowThreads(__tstate);
26443 if (PyErr_Occurred()) SWIG_fail;
26444 }
26445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26446 return resultobj;
26447 fail:
26448 return NULL;
26449 }
26450
26451
26452 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26453 PyObject *resultobj = 0;
26454 wxDateTime *arg1 = (wxDateTime *) 0 ;
26455 wxDateSpan *arg2 = 0 ;
26456 wxDateTime *result = 0 ;
26457 void *argp1 = 0 ;
26458 int res1 = 0 ;
26459 void *argp2 = 0 ;
26460 int res2 = 0 ;
26461
26462 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26464 if (!SWIG_IsOK(res1)) {
26465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26466 }
26467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26468 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26469 if (!SWIG_IsOK(res2)) {
26470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26471 }
26472 if (!argp2) {
26473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26474 }
26475 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 {
26479 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26480 result = (wxDateTime *) &_result_ref;
26481 }
26482 wxPyEndAllowThreads(__tstate);
26483 if (PyErr_Occurred()) SWIG_fail;
26484 }
26485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26486 return resultobj;
26487 fail:
26488 return NULL;
26489 }
26490
26491
26492 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26493 int argc;
26494 PyObject *argv[3];
26495
26496 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26497 --argc;
26498 if (argc == 2) {
26499 int _v = 0;
26500 {
26501 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26502 _v = SWIG_CheckState(res);
26503 }
26504 if (!_v) goto check_1;
26505 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26506 }
26507 check_1:
26508
26509 if (argc == 2) {
26510 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26511 }
26512
26513 fail:
26514 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26515 return NULL;
26516 }
26517
26518
26519 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26520 PyObject *resultobj = 0;
26521 wxDateTime *arg1 = (wxDateTime *) 0 ;
26522 wxTimeSpan *arg2 = 0 ;
26523 wxDateTime result;
26524 void *argp1 = 0 ;
26525 int res1 = 0 ;
26526 void *argp2 = 0 ;
26527 int res2 = 0 ;
26528
26529 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26531 if (!SWIG_IsOK(res1)) {
26532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26533 }
26534 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26535 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26536 if (!SWIG_IsOK(res2)) {
26537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26538 }
26539 if (!argp2) {
26540 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26541 }
26542 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26543 {
26544 PyThreadState* __tstate = wxPyBeginAllowThreads();
26545 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26546 wxPyEndAllowThreads(__tstate);
26547 if (PyErr_Occurred()) SWIG_fail;
26548 }
26549 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26550 return resultobj;
26551 fail:
26552 return NULL;
26553 }
26554
26555
26556 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26557 PyObject *resultobj = 0;
26558 wxDateTime *arg1 = (wxDateTime *) 0 ;
26559 wxDateSpan *arg2 = 0 ;
26560 wxDateTime result;
26561 void *argp1 = 0 ;
26562 int res1 = 0 ;
26563 void *argp2 = 0 ;
26564 int res2 = 0 ;
26565
26566 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26568 if (!SWIG_IsOK(res1)) {
26569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26570 }
26571 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26572 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26573 if (!SWIG_IsOK(res2)) {
26574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26575 }
26576 if (!argp2) {
26577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26578 }
26579 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26587 return resultobj;
26588 fail:
26589 return NULL;
26590 }
26591
26592
26593 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26594 int argc;
26595 PyObject *argv[3];
26596
26597 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26598 --argc;
26599 if (argc == 2) {
26600 int _v = 0;
26601 {
26602 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26603 _v = SWIG_CheckState(res);
26604 }
26605 if (!_v) goto check_1;
26606 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26607 }
26608 check_1:
26609
26610 if (argc == 2) {
26611 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26612 }
26613
26614 fail:
26615 Py_INCREF(Py_NotImplemented);
26616 return Py_NotImplemented;
26617 }
26618
26619
26620 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26621 PyObject *resultobj = 0;
26622 wxDateTime *arg1 = (wxDateTime *) 0 ;
26623 wxDateTime *arg2 = 0 ;
26624 wxTimeSpan result;
26625 void *argp1 = 0 ;
26626 int res1 = 0 ;
26627 void *argp2 = 0 ;
26628 int res2 = 0 ;
26629
26630 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26632 if (!SWIG_IsOK(res1)) {
26633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26634 }
26635 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26636 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26637 if (!SWIG_IsOK(res2)) {
26638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26639 }
26640 if (!argp2) {
26641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26642 }
26643 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26644 {
26645 PyThreadState* __tstate = wxPyBeginAllowThreads();
26646 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26647 wxPyEndAllowThreads(__tstate);
26648 if (PyErr_Occurred()) SWIG_fail;
26649 }
26650 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26651 return resultobj;
26652 fail:
26653 return NULL;
26654 }
26655
26656
26657 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26658 PyObject *resultobj = 0;
26659 wxDateTime *arg1 = (wxDateTime *) 0 ;
26660 wxTimeSpan *arg2 = 0 ;
26661 wxDateTime result;
26662 void *argp1 = 0 ;
26663 int res1 = 0 ;
26664 void *argp2 = 0 ;
26665 int res2 = 0 ;
26666
26667 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26669 if (!SWIG_IsOK(res1)) {
26670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26671 }
26672 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26673 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26674 if (!SWIG_IsOK(res2)) {
26675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26676 }
26677 if (!argp2) {
26678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26679 }
26680 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26681 {
26682 PyThreadState* __tstate = wxPyBeginAllowThreads();
26683 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26688 return resultobj;
26689 fail:
26690 return NULL;
26691 }
26692
26693
26694 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26695 PyObject *resultobj = 0;
26696 wxDateTime *arg1 = (wxDateTime *) 0 ;
26697 wxDateSpan *arg2 = 0 ;
26698 wxDateTime result;
26699 void *argp1 = 0 ;
26700 int res1 = 0 ;
26701 void *argp2 = 0 ;
26702 int res2 = 0 ;
26703
26704 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26706 if (!SWIG_IsOK(res1)) {
26707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26708 }
26709 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26710 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26711 if (!SWIG_IsOK(res2)) {
26712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26713 }
26714 if (!argp2) {
26715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26716 }
26717 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26718 {
26719 PyThreadState* __tstate = wxPyBeginAllowThreads();
26720 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26721 wxPyEndAllowThreads(__tstate);
26722 if (PyErr_Occurred()) SWIG_fail;
26723 }
26724 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26732 int argc;
26733 PyObject *argv[3];
26734
26735 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26736 --argc;
26737 if (argc == 2) {
26738 int _v = 0;
26739 {
26740 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26741 _v = SWIG_CheckState(res);
26742 }
26743 if (!_v) goto check_1;
26744 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26745 }
26746 check_1:
26747
26748 if (argc == 2) {
26749 int _v = 0;
26750 {
26751 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26752 _v = SWIG_CheckState(res);
26753 }
26754 if (!_v) goto check_2;
26755 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26756 }
26757 check_2:
26758
26759 if (argc == 2) {
26760 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26761 }
26762
26763 fail:
26764 Py_INCREF(Py_NotImplemented);
26765 return Py_NotImplemented;
26766 }
26767
26768
26769 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj = 0;
26771 wxDateTime *arg1 = (wxDateTime *) 0 ;
26772 wxDateTime *arg2 = (wxDateTime *) 0 ;
26773 bool result;
26774 void *argp1 = 0 ;
26775 int res1 = 0 ;
26776 void *argp2 = 0 ;
26777 int res2 = 0 ;
26778 PyObject * obj0 = 0 ;
26779 PyObject * obj1 = 0 ;
26780 char * kwnames[] = {
26781 (char *) "self",(char *) "other", NULL
26782 };
26783
26784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26786 if (!SWIG_IsOK(res1)) {
26787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26788 }
26789 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26791 if (!SWIG_IsOK(res2)) {
26792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26793 }
26794 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26795 {
26796 PyThreadState* __tstate = wxPyBeginAllowThreads();
26797 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26798 wxPyEndAllowThreads(__tstate);
26799 if (PyErr_Occurred()) SWIG_fail;
26800 }
26801 {
26802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26803 }
26804 return resultobj;
26805 fail:
26806 return NULL;
26807 }
26808
26809
26810 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26811 PyObject *resultobj = 0;
26812 wxDateTime *arg1 = (wxDateTime *) 0 ;
26813 wxDateTime *arg2 = (wxDateTime *) 0 ;
26814 bool result;
26815 void *argp1 = 0 ;
26816 int res1 = 0 ;
26817 void *argp2 = 0 ;
26818 int res2 = 0 ;
26819 PyObject * obj0 = 0 ;
26820 PyObject * obj1 = 0 ;
26821 char * kwnames[] = {
26822 (char *) "self",(char *) "other", NULL
26823 };
26824
26825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26827 if (!SWIG_IsOK(res1)) {
26828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26829 }
26830 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26832 if (!SWIG_IsOK(res2)) {
26833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26834 }
26835 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26839 wxPyEndAllowThreads(__tstate);
26840 if (PyErr_Occurred()) SWIG_fail;
26841 }
26842 {
26843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26844 }
26845 return resultobj;
26846 fail:
26847 return NULL;
26848 }
26849
26850
26851 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26852 PyObject *resultobj = 0;
26853 wxDateTime *arg1 = (wxDateTime *) 0 ;
26854 wxDateTime *arg2 = (wxDateTime *) 0 ;
26855 bool result;
26856 void *argp1 = 0 ;
26857 int res1 = 0 ;
26858 void *argp2 = 0 ;
26859 int res2 = 0 ;
26860 PyObject * obj0 = 0 ;
26861 PyObject * obj1 = 0 ;
26862 char * kwnames[] = {
26863 (char *) "self",(char *) "other", NULL
26864 };
26865
26866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26870 }
26871 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26872 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26873 if (!SWIG_IsOK(res2)) {
26874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26875 }
26876 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26877 {
26878 PyThreadState* __tstate = wxPyBeginAllowThreads();
26879 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 {
26884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26885 }
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26893 PyObject *resultobj = 0;
26894 wxDateTime *arg1 = (wxDateTime *) 0 ;
26895 wxDateTime *arg2 = (wxDateTime *) 0 ;
26896 bool result;
26897 void *argp1 = 0 ;
26898 int res1 = 0 ;
26899 void *argp2 = 0 ;
26900 int res2 = 0 ;
26901 PyObject * obj0 = 0 ;
26902 PyObject * obj1 = 0 ;
26903 char * kwnames[] = {
26904 (char *) "self",(char *) "other", NULL
26905 };
26906
26907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26911 }
26912 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26913 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26914 if (!SWIG_IsOK(res2)) {
26915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26916 }
26917 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26918 {
26919 PyThreadState* __tstate = wxPyBeginAllowThreads();
26920 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26921 wxPyEndAllowThreads(__tstate);
26922 if (PyErr_Occurred()) SWIG_fail;
26923 }
26924 {
26925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26926 }
26927 return resultobj;
26928 fail:
26929 return NULL;
26930 }
26931
26932
26933 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26934 PyObject *resultobj = 0;
26935 wxDateTime *arg1 = (wxDateTime *) 0 ;
26936 wxDateTime *arg2 = (wxDateTime *) 0 ;
26937 bool result;
26938 void *argp1 = 0 ;
26939 int res1 = 0 ;
26940 void *argp2 = 0 ;
26941 int res2 = 0 ;
26942 PyObject * obj0 = 0 ;
26943 PyObject * obj1 = 0 ;
26944 char * kwnames[] = {
26945 (char *) "self",(char *) "other", NULL
26946 };
26947
26948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26950 if (!SWIG_IsOK(res1)) {
26951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26952 }
26953 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26954 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26955 if (!SWIG_IsOK(res2)) {
26956 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26957 }
26958 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 {
26966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26967 }
26968 return resultobj;
26969 fail:
26970 return NULL;
26971 }
26972
26973
26974 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26975 PyObject *resultobj = 0;
26976 wxDateTime *arg1 = (wxDateTime *) 0 ;
26977 wxDateTime *arg2 = (wxDateTime *) 0 ;
26978 bool result;
26979 void *argp1 = 0 ;
26980 int res1 = 0 ;
26981 void *argp2 = 0 ;
26982 int res2 = 0 ;
26983 PyObject * obj0 = 0 ;
26984 PyObject * obj1 = 0 ;
26985 char * kwnames[] = {
26986 (char *) "self",(char *) "other", NULL
26987 };
26988
26989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26991 if (!SWIG_IsOK(res1)) {
26992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26993 }
26994 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26995 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26996 if (!SWIG_IsOK(res2)) {
26997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26998 }
26999 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 {
27007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27008 }
27009 return resultobj;
27010 fail:
27011 return NULL;
27012 }
27013
27014
27015 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27016 PyObject *resultobj = 0;
27017 wxDateTime *arg1 = (wxDateTime *) 0 ;
27018 wxString *arg2 = 0 ;
27019 int result;
27020 void *argp1 = 0 ;
27021 int res1 = 0 ;
27022 bool temp2 = false ;
27023 PyObject * obj0 = 0 ;
27024 PyObject * obj1 = 0 ;
27025 char * kwnames[] = {
27026 (char *) "self",(char *) "date", NULL
27027 };
27028
27029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27031 if (!SWIG_IsOK(res1)) {
27032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27033 }
27034 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27035 {
27036 arg2 = wxString_in_helper(obj1);
27037 if (arg2 == NULL) SWIG_fail;
27038 temp2 = true;
27039 }
27040 {
27041 PyThreadState* __tstate = wxPyBeginAllowThreads();
27042 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 resultobj = SWIG_From_int(static_cast< int >(result));
27047 {
27048 if (temp2)
27049 delete arg2;
27050 }
27051 return resultobj;
27052 fail:
27053 {
27054 if (temp2)
27055 delete arg2;
27056 }
27057 return NULL;
27058 }
27059
27060
27061 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27062 PyObject *resultobj = 0;
27063 wxDateTime *arg1 = (wxDateTime *) 0 ;
27064 wxString *arg2 = 0 ;
27065 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27066 wxString *arg3 = (wxString *) &arg3_defvalue ;
27067 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27068 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27069 int result;
27070 void *argp1 = 0 ;
27071 int res1 = 0 ;
27072 bool temp2 = false ;
27073 bool temp3 = false ;
27074 void *argp4 = 0 ;
27075 int res4 = 0 ;
27076 PyObject * obj0 = 0 ;
27077 PyObject * obj1 = 0 ;
27078 PyObject * obj2 = 0 ;
27079 PyObject * obj3 = 0 ;
27080 char * kwnames[] = {
27081 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27082 };
27083
27084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27086 if (!SWIG_IsOK(res1)) {
27087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27088 }
27089 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27090 {
27091 arg2 = wxString_in_helper(obj1);
27092 if (arg2 == NULL) SWIG_fail;
27093 temp2 = true;
27094 }
27095 if (obj2) {
27096 {
27097 arg3 = wxString_in_helper(obj2);
27098 if (arg3 == NULL) SWIG_fail;
27099 temp3 = true;
27100 }
27101 }
27102 if (obj3) {
27103 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
27104 if (!SWIG_IsOK(res4)) {
27105 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27106 }
27107 if (!argp4) {
27108 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27109 }
27110 arg4 = reinterpret_cast< wxDateTime * >(argp4);
27111 }
27112 {
27113 PyThreadState* __tstate = wxPyBeginAllowThreads();
27114 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
27115 wxPyEndAllowThreads(__tstate);
27116 if (PyErr_Occurred()) SWIG_fail;
27117 }
27118 resultobj = SWIG_From_int(static_cast< int >(result));
27119 {
27120 if (temp2)
27121 delete arg2;
27122 }
27123 {
27124 if (temp3)
27125 delete arg3;
27126 }
27127 return resultobj;
27128 fail:
27129 {
27130 if (temp2)
27131 delete arg2;
27132 }
27133 {
27134 if (temp3)
27135 delete arg3;
27136 }
27137 return NULL;
27138 }
27139
27140
27141 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27142 PyObject *resultobj = 0;
27143 wxDateTime *arg1 = (wxDateTime *) 0 ;
27144 wxString *arg2 = 0 ;
27145 int result;
27146 void *argp1 = 0 ;
27147 int res1 = 0 ;
27148 bool temp2 = false ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char * kwnames[] = {
27152 (char *) "self",(char *) "datetime", NULL
27153 };
27154
27155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
27156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27159 }
27160 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27161 {
27162 arg2 = wxString_in_helper(obj1);
27163 if (arg2 == NULL) SWIG_fail;
27164 temp2 = true;
27165 }
27166 {
27167 PyThreadState* __tstate = wxPyBeginAllowThreads();
27168 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
27169 wxPyEndAllowThreads(__tstate);
27170 if (PyErr_Occurred()) SWIG_fail;
27171 }
27172 resultobj = SWIG_From_int(static_cast< int >(result));
27173 {
27174 if (temp2)
27175 delete arg2;
27176 }
27177 return resultobj;
27178 fail:
27179 {
27180 if (temp2)
27181 delete arg2;
27182 }
27183 return NULL;
27184 }
27185
27186
27187 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27188 PyObject *resultobj = 0;
27189 wxDateTime *arg1 = (wxDateTime *) 0 ;
27190 wxString *arg2 = 0 ;
27191 int result;
27192 void *argp1 = 0 ;
27193 int res1 = 0 ;
27194 bool temp2 = false ;
27195 PyObject * obj0 = 0 ;
27196 PyObject * obj1 = 0 ;
27197 char * kwnames[] = {
27198 (char *) "self",(char *) "date", NULL
27199 };
27200
27201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27203 if (!SWIG_IsOK(res1)) {
27204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27205 }
27206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27207 {
27208 arg2 = wxString_in_helper(obj1);
27209 if (arg2 == NULL) SWIG_fail;
27210 temp2 = true;
27211 }
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 resultobj = SWIG_From_int(static_cast< int >(result));
27219 {
27220 if (temp2)
27221 delete arg2;
27222 }
27223 return resultobj;
27224 fail:
27225 {
27226 if (temp2)
27227 delete arg2;
27228 }
27229 return NULL;
27230 }
27231
27232
27233 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27234 PyObject *resultobj = 0;
27235 wxDateTime *arg1 = (wxDateTime *) 0 ;
27236 wxString *arg2 = 0 ;
27237 int result;
27238 void *argp1 = 0 ;
27239 int res1 = 0 ;
27240 bool temp2 = false ;
27241 PyObject * obj0 = 0 ;
27242 PyObject * obj1 = 0 ;
27243 char * kwnames[] = {
27244 (char *) "self",(char *) "time", NULL
27245 };
27246
27247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27249 if (!SWIG_IsOK(res1)) {
27250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27251 }
27252 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27253 {
27254 arg2 = wxString_in_helper(obj1);
27255 if (arg2 == NULL) SWIG_fail;
27256 temp2 = true;
27257 }
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27261 wxPyEndAllowThreads(__tstate);
27262 if (PyErr_Occurred()) SWIG_fail;
27263 }
27264 resultobj = SWIG_From_int(static_cast< int >(result));
27265 {
27266 if (temp2)
27267 delete arg2;
27268 }
27269 return resultobj;
27270 fail:
27271 {
27272 if (temp2)
27273 delete arg2;
27274 }
27275 return NULL;
27276 }
27277
27278
27279 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27280 PyObject *resultobj = 0;
27281 wxDateTime *arg1 = (wxDateTime *) 0 ;
27282 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27283 wxString *arg2 = (wxString *) &arg2_defvalue ;
27284 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27285 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27286 wxString result;
27287 void *argp1 = 0 ;
27288 int res1 = 0 ;
27289 bool temp2 = false ;
27290 bool temp3 = false ;
27291 PyObject * obj0 = 0 ;
27292 PyObject * obj1 = 0 ;
27293 PyObject * obj2 = 0 ;
27294 char * kwnames[] = {
27295 (char *) "self",(char *) "format",(char *) "tz", NULL
27296 };
27297
27298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27300 if (!SWIG_IsOK(res1)) {
27301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27302 }
27303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27304 if (obj1) {
27305 {
27306 arg2 = wxString_in_helper(obj1);
27307 if (arg2 == NULL) SWIG_fail;
27308 temp2 = true;
27309 }
27310 }
27311 if (obj2) {
27312 {
27313 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27314 temp3 = true;
27315 }
27316 }
27317 {
27318 PyThreadState* __tstate = wxPyBeginAllowThreads();
27319 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27320 wxPyEndAllowThreads(__tstate);
27321 if (PyErr_Occurred()) SWIG_fail;
27322 }
27323 {
27324 #if wxUSE_UNICODE
27325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27326 #else
27327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27328 #endif
27329 }
27330 {
27331 if (temp2)
27332 delete arg2;
27333 }
27334 {
27335 if (temp3) delete arg3;
27336 }
27337 return resultobj;
27338 fail:
27339 {
27340 if (temp2)
27341 delete arg2;
27342 }
27343 {
27344 if (temp3) delete arg3;
27345 }
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27351 PyObject *resultobj = 0;
27352 wxDateTime *arg1 = (wxDateTime *) 0 ;
27353 wxString result;
27354 void *argp1 = 0 ;
27355 int res1 = 0 ;
27356 PyObject *swig_obj[1] ;
27357
27358 if (!args) SWIG_fail;
27359 swig_obj[0] = args;
27360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27361 if (!SWIG_IsOK(res1)) {
27362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27363 }
27364 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27365 {
27366 PyThreadState* __tstate = wxPyBeginAllowThreads();
27367 result = ((wxDateTime const *)arg1)->FormatDate();
27368 wxPyEndAllowThreads(__tstate);
27369 if (PyErr_Occurred()) SWIG_fail;
27370 }
27371 {
27372 #if wxUSE_UNICODE
27373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27374 #else
27375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27376 #endif
27377 }
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27385 PyObject *resultobj = 0;
27386 wxDateTime *arg1 = (wxDateTime *) 0 ;
27387 wxString result;
27388 void *argp1 = 0 ;
27389 int res1 = 0 ;
27390 PyObject *swig_obj[1] ;
27391
27392 if (!args) SWIG_fail;
27393 swig_obj[0] = args;
27394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27395 if (!SWIG_IsOK(res1)) {
27396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27397 }
27398 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = ((wxDateTime const *)arg1)->FormatTime();
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 #if wxUSE_UNICODE
27407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27408 #else
27409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27410 #endif
27411 }
27412 return resultobj;
27413 fail:
27414 return NULL;
27415 }
27416
27417
27418 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27419 PyObject *resultobj = 0;
27420 wxDateTime *arg1 = (wxDateTime *) 0 ;
27421 wxString result;
27422 void *argp1 = 0 ;
27423 int res1 = 0 ;
27424 PyObject *swig_obj[1] ;
27425
27426 if (!args) SWIG_fail;
27427 swig_obj[0] = args;
27428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27429 if (!SWIG_IsOK(res1)) {
27430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27431 }
27432 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27433 {
27434 PyThreadState* __tstate = wxPyBeginAllowThreads();
27435 result = ((wxDateTime const *)arg1)->FormatISODate();
27436 wxPyEndAllowThreads(__tstate);
27437 if (PyErr_Occurred()) SWIG_fail;
27438 }
27439 {
27440 #if wxUSE_UNICODE
27441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27442 #else
27443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27444 #endif
27445 }
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27453 PyObject *resultobj = 0;
27454 wxDateTime *arg1 = (wxDateTime *) 0 ;
27455 wxString result;
27456 void *argp1 = 0 ;
27457 int res1 = 0 ;
27458 PyObject *swig_obj[1] ;
27459
27460 if (!args) SWIG_fail;
27461 swig_obj[0] = args;
27462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27465 }
27466 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27467 {
27468 PyThreadState* __tstate = wxPyBeginAllowThreads();
27469 result = ((wxDateTime const *)arg1)->FormatISOTime();
27470 wxPyEndAllowThreads(__tstate);
27471 if (PyErr_Occurred()) SWIG_fail;
27472 }
27473 {
27474 #if wxUSE_UNICODE
27475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27476 #else
27477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27478 #endif
27479 }
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27487 PyObject *obj;
27488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27489 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27490 return SWIG_Py_Void();
27491 }
27492
27493 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27494 return SWIG_Python_InitShadowInstance(args);
27495 }
27496
27497 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27498 PyObject *resultobj = 0;
27499 long arg1 ;
27500 wxTimeSpan result;
27501 long val1 ;
27502 int ecode1 = 0 ;
27503 PyObject * obj0 = 0 ;
27504 char * kwnames[] = {
27505 (char *) "ms", NULL
27506 };
27507
27508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27509 ecode1 = SWIG_AsVal_long(obj0, &val1);
27510 if (!SWIG_IsOK(ecode1)) {
27511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27512 }
27513 arg1 = static_cast< long >(val1);
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 result = wxTimeSpan::Milliseconds(arg1);
27517 wxPyEndAllowThreads(__tstate);
27518 if (PyErr_Occurred()) SWIG_fail;
27519 }
27520 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27528 PyObject *resultobj = 0;
27529 wxTimeSpan result;
27530
27531 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27532 {
27533 PyThreadState* __tstate = wxPyBeginAllowThreads();
27534 result = wxTimeSpan::Millisecond();
27535 wxPyEndAllowThreads(__tstate);
27536 if (PyErr_Occurred()) SWIG_fail;
27537 }
27538 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27539 return resultobj;
27540 fail:
27541 return NULL;
27542 }
27543
27544
27545 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27546 PyObject *resultobj = 0;
27547 long arg1 ;
27548 wxTimeSpan result;
27549 long val1 ;
27550 int ecode1 = 0 ;
27551 PyObject * obj0 = 0 ;
27552 char * kwnames[] = {
27553 (char *) "sec", NULL
27554 };
27555
27556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27557 ecode1 = SWIG_AsVal_long(obj0, &val1);
27558 if (!SWIG_IsOK(ecode1)) {
27559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27560 }
27561 arg1 = static_cast< long >(val1);
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 result = wxTimeSpan::Seconds(arg1);
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27569 return resultobj;
27570 fail:
27571 return NULL;
27572 }
27573
27574
27575 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27576 PyObject *resultobj = 0;
27577 wxTimeSpan result;
27578
27579 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = wxTimeSpan::Second();
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj = 0;
27595 long arg1 ;
27596 wxTimeSpan result;
27597 long val1 ;
27598 int ecode1 = 0 ;
27599 PyObject * obj0 = 0 ;
27600 char * kwnames[] = {
27601 (char *) "min", NULL
27602 };
27603
27604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27605 ecode1 = SWIG_AsVal_long(obj0, &val1);
27606 if (!SWIG_IsOK(ecode1)) {
27607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27608 }
27609 arg1 = static_cast< long >(val1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = wxTimeSpan::Minutes(arg1);
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27624 PyObject *resultobj = 0;
27625 wxTimeSpan result;
27626
27627 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27628 {
27629 PyThreadState* __tstate = wxPyBeginAllowThreads();
27630 result = wxTimeSpan::Minute();
27631 wxPyEndAllowThreads(__tstate);
27632 if (PyErr_Occurred()) SWIG_fail;
27633 }
27634 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27635 return resultobj;
27636 fail:
27637 return NULL;
27638 }
27639
27640
27641 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27642 PyObject *resultobj = 0;
27643 long arg1 ;
27644 wxTimeSpan result;
27645 long val1 ;
27646 int ecode1 = 0 ;
27647 PyObject * obj0 = 0 ;
27648 char * kwnames[] = {
27649 (char *) "hours", NULL
27650 };
27651
27652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27653 ecode1 = SWIG_AsVal_long(obj0, &val1);
27654 if (!SWIG_IsOK(ecode1)) {
27655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27656 }
27657 arg1 = static_cast< long >(val1);
27658 {
27659 PyThreadState* __tstate = wxPyBeginAllowThreads();
27660 result = wxTimeSpan::Hours(arg1);
27661 wxPyEndAllowThreads(__tstate);
27662 if (PyErr_Occurred()) SWIG_fail;
27663 }
27664 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27672 PyObject *resultobj = 0;
27673 wxTimeSpan result;
27674
27675 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27676 {
27677 PyThreadState* __tstate = wxPyBeginAllowThreads();
27678 result = wxTimeSpan::Hour();
27679 wxPyEndAllowThreads(__tstate);
27680 if (PyErr_Occurred()) SWIG_fail;
27681 }
27682 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27683 return resultobj;
27684 fail:
27685 return NULL;
27686 }
27687
27688
27689 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27690 PyObject *resultobj = 0;
27691 long arg1 ;
27692 wxTimeSpan result;
27693 long val1 ;
27694 int ecode1 = 0 ;
27695 PyObject * obj0 = 0 ;
27696 char * kwnames[] = {
27697 (char *) "days", NULL
27698 };
27699
27700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27701 ecode1 = SWIG_AsVal_long(obj0, &val1);
27702 if (!SWIG_IsOK(ecode1)) {
27703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27704 }
27705 arg1 = static_cast< long >(val1);
27706 {
27707 PyThreadState* __tstate = wxPyBeginAllowThreads();
27708 result = wxTimeSpan::Days(arg1);
27709 wxPyEndAllowThreads(__tstate);
27710 if (PyErr_Occurred()) SWIG_fail;
27711 }
27712 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27713 return resultobj;
27714 fail:
27715 return NULL;
27716 }
27717
27718
27719 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27720 PyObject *resultobj = 0;
27721 wxTimeSpan result;
27722
27723 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27724 {
27725 PyThreadState* __tstate = wxPyBeginAllowThreads();
27726 result = wxTimeSpan::Day();
27727 wxPyEndAllowThreads(__tstate);
27728 if (PyErr_Occurred()) SWIG_fail;
27729 }
27730 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27731 return resultobj;
27732 fail:
27733 return NULL;
27734 }
27735
27736
27737 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27738 PyObject *resultobj = 0;
27739 long arg1 ;
27740 wxTimeSpan result;
27741 long val1 ;
27742 int ecode1 = 0 ;
27743 PyObject * obj0 = 0 ;
27744 char * kwnames[] = {
27745 (char *) "days", NULL
27746 };
27747
27748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27749 ecode1 = SWIG_AsVal_long(obj0, &val1);
27750 if (!SWIG_IsOK(ecode1)) {
27751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27752 }
27753 arg1 = static_cast< long >(val1);
27754 {
27755 PyThreadState* __tstate = wxPyBeginAllowThreads();
27756 result = wxTimeSpan::Weeks(arg1);
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27768 PyObject *resultobj = 0;
27769 wxTimeSpan result;
27770
27771 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = wxTimeSpan::Week();
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27786 PyObject *resultobj = 0;
27787 long arg1 = (long) 0 ;
27788 long arg2 = (long) 0 ;
27789 long arg3 = (long) 0 ;
27790 long arg4 = (long) 0 ;
27791 wxTimeSpan *result = 0 ;
27792 long val1 ;
27793 int ecode1 = 0 ;
27794 long val2 ;
27795 int ecode2 = 0 ;
27796 long val3 ;
27797 int ecode3 = 0 ;
27798 long val4 ;
27799 int ecode4 = 0 ;
27800 PyObject * obj0 = 0 ;
27801 PyObject * obj1 = 0 ;
27802 PyObject * obj2 = 0 ;
27803 PyObject * obj3 = 0 ;
27804 char * kwnames[] = {
27805 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27806 };
27807
27808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27809 if (obj0) {
27810 ecode1 = SWIG_AsVal_long(obj0, &val1);
27811 if (!SWIG_IsOK(ecode1)) {
27812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27813 }
27814 arg1 = static_cast< long >(val1);
27815 }
27816 if (obj1) {
27817 ecode2 = SWIG_AsVal_long(obj1, &val2);
27818 if (!SWIG_IsOK(ecode2)) {
27819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27820 }
27821 arg2 = static_cast< long >(val2);
27822 }
27823 if (obj2) {
27824 ecode3 = SWIG_AsVal_long(obj2, &val3);
27825 if (!SWIG_IsOK(ecode3)) {
27826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27827 }
27828 arg3 = static_cast< long >(val3);
27829 }
27830 if (obj3) {
27831 ecode4 = SWIG_AsVal_long(obj3, &val4);
27832 if (!SWIG_IsOK(ecode4)) {
27833 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27834 }
27835 arg4 = static_cast< long >(val4);
27836 }
27837 {
27838 PyThreadState* __tstate = wxPyBeginAllowThreads();
27839 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27840 wxPyEndAllowThreads(__tstate);
27841 if (PyErr_Occurred()) SWIG_fail;
27842 }
27843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27844 return resultobj;
27845 fail:
27846 return NULL;
27847 }
27848
27849
27850 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27851 PyObject *resultobj = 0;
27852 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27853 void *argp1 = 0 ;
27854 int res1 = 0 ;
27855 PyObject *swig_obj[1] ;
27856
27857 if (!args) SWIG_fail;
27858 swig_obj[0] = args;
27859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27860 if (!SWIG_IsOK(res1)) {
27861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27862 }
27863 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27864 {
27865 PyThreadState* __tstate = wxPyBeginAllowThreads();
27866 delete arg1;
27867
27868 wxPyEndAllowThreads(__tstate);
27869 if (PyErr_Occurred()) SWIG_fail;
27870 }
27871 resultobj = SWIG_Py_Void();
27872 return resultobj;
27873 fail:
27874 return NULL;
27875 }
27876
27877
27878 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27879 PyObject *resultobj = 0;
27880 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27881 wxTimeSpan *arg2 = 0 ;
27882 wxTimeSpan *result = 0 ;
27883 void *argp1 = 0 ;
27884 int res1 = 0 ;
27885 void *argp2 = 0 ;
27886 int res2 = 0 ;
27887 PyObject * obj0 = 0 ;
27888 PyObject * obj1 = 0 ;
27889 char * kwnames[] = {
27890 (char *) "self",(char *) "diff", NULL
27891 };
27892
27893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27895 if (!SWIG_IsOK(res1)) {
27896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27897 }
27898 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27900 if (!SWIG_IsOK(res2)) {
27901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27902 }
27903 if (!argp2) {
27904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27905 }
27906 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27907 {
27908 PyThreadState* __tstate = wxPyBeginAllowThreads();
27909 {
27910 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27911 result = (wxTimeSpan *) &_result_ref;
27912 }
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27917 return resultobj;
27918 fail:
27919 return NULL;
27920 }
27921
27922
27923 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27924 PyObject *resultobj = 0;
27925 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27926 wxTimeSpan *arg2 = 0 ;
27927 wxTimeSpan *result = 0 ;
27928 void *argp1 = 0 ;
27929 int res1 = 0 ;
27930 void *argp2 = 0 ;
27931 int res2 = 0 ;
27932 PyObject * obj0 = 0 ;
27933 PyObject * obj1 = 0 ;
27934 char * kwnames[] = {
27935 (char *) "self",(char *) "diff", NULL
27936 };
27937
27938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27940 if (!SWIG_IsOK(res1)) {
27941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27942 }
27943 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27944 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27945 if (!SWIG_IsOK(res2)) {
27946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27947 }
27948 if (!argp2) {
27949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27950 }
27951 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27952 {
27953 PyThreadState* __tstate = wxPyBeginAllowThreads();
27954 {
27955 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27956 result = (wxTimeSpan *) &_result_ref;
27957 }
27958 wxPyEndAllowThreads(__tstate);
27959 if (PyErr_Occurred()) SWIG_fail;
27960 }
27961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27962 return resultobj;
27963 fail:
27964 return NULL;
27965 }
27966
27967
27968 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27969 PyObject *resultobj = 0;
27970 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27971 int arg2 ;
27972 wxTimeSpan *result = 0 ;
27973 void *argp1 = 0 ;
27974 int res1 = 0 ;
27975 int val2 ;
27976 int ecode2 = 0 ;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char * kwnames[] = {
27980 (char *) "self",(char *) "n", NULL
27981 };
27982
27983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27985 if (!SWIG_IsOK(res1)) {
27986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27987 }
27988 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27989 ecode2 = SWIG_AsVal_int(obj1, &val2);
27990 if (!SWIG_IsOK(ecode2)) {
27991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27992 }
27993 arg2 = static_cast< int >(val2);
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 {
27997 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27998 result = (wxTimeSpan *) &_result_ref;
27999 }
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28011 PyObject *resultobj = 0;
28012 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28013 wxTimeSpan *result = 0 ;
28014 void *argp1 = 0 ;
28015 int res1 = 0 ;
28016 PyObject *swig_obj[1] ;
28017
28018 if (!args) SWIG_fail;
28019 swig_obj[0] = args;
28020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28021 if (!SWIG_IsOK(res1)) {
28022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28023 }
28024 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28025 {
28026 PyThreadState* __tstate = wxPyBeginAllowThreads();
28027 {
28028 wxTimeSpan &_result_ref = (arg1)->Neg();
28029 result = (wxTimeSpan *) &_result_ref;
28030 }
28031 wxPyEndAllowThreads(__tstate);
28032 if (PyErr_Occurred()) SWIG_fail;
28033 }
28034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28035 return resultobj;
28036 fail:
28037 return NULL;
28038 }
28039
28040
28041 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28042 PyObject *resultobj = 0;
28043 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28044 wxTimeSpan result;
28045 void *argp1 = 0 ;
28046 int res1 = 0 ;
28047 PyObject *swig_obj[1] ;
28048
28049 if (!args) SWIG_fail;
28050 swig_obj[0] = args;
28051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28052 if (!SWIG_IsOK(res1)) {
28053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28054 }
28055 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28056 {
28057 PyThreadState* __tstate = wxPyBeginAllowThreads();
28058 result = ((wxTimeSpan const *)arg1)->Abs();
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28063 return resultobj;
28064 fail:
28065 return NULL;
28066 }
28067
28068
28069 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj = 0;
28071 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28072 wxTimeSpan *arg2 = 0 ;
28073 wxTimeSpan *result = 0 ;
28074 void *argp1 = 0 ;
28075 int res1 = 0 ;
28076 void *argp2 = 0 ;
28077 int res2 = 0 ;
28078 PyObject * obj0 = 0 ;
28079 PyObject * obj1 = 0 ;
28080 char * kwnames[] = {
28081 (char *) "self",(char *) "diff", NULL
28082 };
28083
28084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28086 if (!SWIG_IsOK(res1)) {
28087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28088 }
28089 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28091 if (!SWIG_IsOK(res2)) {
28092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28093 }
28094 if (!argp2) {
28095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28096 }
28097 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28098 {
28099 PyThreadState* __tstate = wxPyBeginAllowThreads();
28100 {
28101 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
28102 result = (wxTimeSpan *) &_result_ref;
28103 }
28104 wxPyEndAllowThreads(__tstate);
28105 if (PyErr_Occurred()) SWIG_fail;
28106 }
28107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28115 PyObject *resultobj = 0;
28116 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28117 wxTimeSpan *arg2 = 0 ;
28118 wxTimeSpan *result = 0 ;
28119 void *argp1 = 0 ;
28120 int res1 = 0 ;
28121 void *argp2 = 0 ;
28122 int res2 = 0 ;
28123 PyObject * obj0 = 0 ;
28124 PyObject * obj1 = 0 ;
28125 char * kwnames[] = {
28126 (char *) "self",(char *) "diff", NULL
28127 };
28128
28129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
28130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28131 if (!SWIG_IsOK(res1)) {
28132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28133 }
28134 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28136 if (!SWIG_IsOK(res2)) {
28137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28138 }
28139 if (!argp2) {
28140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28141 }
28142 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 {
28146 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
28147 result = (wxTimeSpan *) &_result_ref;
28148 }
28149 wxPyEndAllowThreads(__tstate);
28150 if (PyErr_Occurred()) SWIG_fail;
28151 }
28152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28153 return resultobj;
28154 fail:
28155 return NULL;
28156 }
28157
28158
28159 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28160 PyObject *resultobj = 0;
28161 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28162 int arg2 ;
28163 wxTimeSpan *result = 0 ;
28164 void *argp1 = 0 ;
28165 int res1 = 0 ;
28166 int val2 ;
28167 int ecode2 = 0 ;
28168 PyObject * obj0 = 0 ;
28169 PyObject * obj1 = 0 ;
28170 char * kwnames[] = {
28171 (char *) "self",(char *) "n", NULL
28172 };
28173
28174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28176 if (!SWIG_IsOK(res1)) {
28177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28178 }
28179 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28180 ecode2 = SWIG_AsVal_int(obj1, &val2);
28181 if (!SWIG_IsOK(ecode2)) {
28182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28183 }
28184 arg2 = static_cast< int >(val2);
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 {
28188 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28189 result = (wxTimeSpan *) &_result_ref;
28190 }
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28195 return resultobj;
28196 fail:
28197 return NULL;
28198 }
28199
28200
28201 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28202 PyObject *resultobj = 0;
28203 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28204 wxTimeSpan *result = 0 ;
28205 void *argp1 = 0 ;
28206 int res1 = 0 ;
28207 PyObject *swig_obj[1] ;
28208
28209 if (!args) SWIG_fail;
28210 swig_obj[0] = args;
28211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28212 if (!SWIG_IsOK(res1)) {
28213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28214 }
28215 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28216 {
28217 PyThreadState* __tstate = wxPyBeginAllowThreads();
28218 {
28219 wxTimeSpan &_result_ref = (arg1)->operator -();
28220 result = (wxTimeSpan *) &_result_ref;
28221 }
28222 wxPyEndAllowThreads(__tstate);
28223 if (PyErr_Occurred()) SWIG_fail;
28224 }
28225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28226 return resultobj;
28227 fail:
28228 return NULL;
28229 }
28230
28231
28232 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28233 PyObject *resultobj = 0;
28234 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28235 wxTimeSpan *arg2 = 0 ;
28236 wxTimeSpan result;
28237 void *argp1 = 0 ;
28238 int res1 = 0 ;
28239 void *argp2 = 0 ;
28240 int res2 = 0 ;
28241 PyObject * obj0 = 0 ;
28242 PyObject * obj1 = 0 ;
28243 char * kwnames[] = {
28244 (char *) "self",(char *) "other", NULL
28245 };
28246
28247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28249 if (!SWIG_IsOK(res1)) {
28250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28251 }
28252 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28254 if (!SWIG_IsOK(res2)) {
28255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28256 }
28257 if (!argp2) {
28258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28259 }
28260 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28261 {
28262 PyThreadState* __tstate = wxPyBeginAllowThreads();
28263 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28264 wxPyEndAllowThreads(__tstate);
28265 if (PyErr_Occurred()) SWIG_fail;
28266 }
28267 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj = 0;
28276 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28277 wxTimeSpan *arg2 = 0 ;
28278 wxTimeSpan result;
28279 void *argp1 = 0 ;
28280 int res1 = 0 ;
28281 void *argp2 = 0 ;
28282 int res2 = 0 ;
28283 PyObject * obj0 = 0 ;
28284 PyObject * obj1 = 0 ;
28285 char * kwnames[] = {
28286 (char *) "self",(char *) "other", NULL
28287 };
28288
28289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28291 if (!SWIG_IsOK(res1)) {
28292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28293 }
28294 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28296 if (!SWIG_IsOK(res2)) {
28297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28298 }
28299 if (!argp2) {
28300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28301 }
28302 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28303 {
28304 PyThreadState* __tstate = wxPyBeginAllowThreads();
28305 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28317 PyObject *resultobj = 0;
28318 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28319 int arg2 ;
28320 wxTimeSpan result;
28321 void *argp1 = 0 ;
28322 int res1 = 0 ;
28323 int val2 ;
28324 int ecode2 = 0 ;
28325 PyObject * obj0 = 0 ;
28326 PyObject * obj1 = 0 ;
28327 char * kwnames[] = {
28328 (char *) "self",(char *) "n", NULL
28329 };
28330
28331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28333 if (!SWIG_IsOK(res1)) {
28334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28335 }
28336 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28337 ecode2 = SWIG_AsVal_int(obj1, &val2);
28338 if (!SWIG_IsOK(ecode2)) {
28339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28340 }
28341 arg2 = static_cast< int >(val2);
28342 {
28343 PyThreadState* __tstate = wxPyBeginAllowThreads();
28344 result = wxTimeSpan___mul__(arg1,arg2);
28345 wxPyEndAllowThreads(__tstate);
28346 if (PyErr_Occurred()) SWIG_fail;
28347 }
28348 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28356 PyObject *resultobj = 0;
28357 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28358 int arg2 ;
28359 wxTimeSpan result;
28360 void *argp1 = 0 ;
28361 int res1 = 0 ;
28362 int val2 ;
28363 int ecode2 = 0 ;
28364 PyObject * obj0 = 0 ;
28365 PyObject * obj1 = 0 ;
28366 char * kwnames[] = {
28367 (char *) "self",(char *) "n", NULL
28368 };
28369
28370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28372 if (!SWIG_IsOK(res1)) {
28373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28374 }
28375 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28376 ecode2 = SWIG_AsVal_int(obj1, &val2);
28377 if (!SWIG_IsOK(ecode2)) {
28378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28379 }
28380 arg2 = static_cast< int >(val2);
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 result = wxTimeSpan___rmul__(arg1,arg2);
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28388 return resultobj;
28389 fail:
28390 return NULL;
28391 }
28392
28393
28394 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28395 PyObject *resultobj = 0;
28396 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28397 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28398 bool result;
28399 void *argp1 = 0 ;
28400 int res1 = 0 ;
28401 void *argp2 = 0 ;
28402 int res2 = 0 ;
28403 PyObject * obj0 = 0 ;
28404 PyObject * obj1 = 0 ;
28405 char * kwnames[] = {
28406 (char *) "self",(char *) "other", NULL
28407 };
28408
28409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28411 if (!SWIG_IsOK(res1)) {
28412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28413 }
28414 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28416 if (!SWIG_IsOK(res2)) {
28417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28418 }
28419 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28420 {
28421 PyThreadState* __tstate = wxPyBeginAllowThreads();
28422 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28423 wxPyEndAllowThreads(__tstate);
28424 if (PyErr_Occurred()) SWIG_fail;
28425 }
28426 {
28427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28428 }
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28436 PyObject *resultobj = 0;
28437 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28438 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28439 bool result;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 void *argp2 = 0 ;
28443 int res2 = 0 ;
28444 PyObject * obj0 = 0 ;
28445 PyObject * obj1 = 0 ;
28446 char * kwnames[] = {
28447 (char *) "self",(char *) "other", NULL
28448 };
28449
28450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28452 if (!SWIG_IsOK(res1)) {
28453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28454 }
28455 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28457 if (!SWIG_IsOK(res2)) {
28458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28459 }
28460 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 {
28468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28469 }
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28477 PyObject *resultobj = 0;
28478 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28479 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28480 bool result;
28481 void *argp1 = 0 ;
28482 int res1 = 0 ;
28483 void *argp2 = 0 ;
28484 int res2 = 0 ;
28485 PyObject * obj0 = 0 ;
28486 PyObject * obj1 = 0 ;
28487 char * kwnames[] = {
28488 (char *) "self",(char *) "other", NULL
28489 };
28490
28491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28495 }
28496 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28498 if (!SWIG_IsOK(res2)) {
28499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28500 }
28501 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28502 {
28503 PyThreadState* __tstate = wxPyBeginAllowThreads();
28504 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28505 wxPyEndAllowThreads(__tstate);
28506 if (PyErr_Occurred()) SWIG_fail;
28507 }
28508 {
28509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28510 }
28511 return resultobj;
28512 fail:
28513 return NULL;
28514 }
28515
28516
28517 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28518 PyObject *resultobj = 0;
28519 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28520 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28521 bool result;
28522 void *argp1 = 0 ;
28523 int res1 = 0 ;
28524 void *argp2 = 0 ;
28525 int res2 = 0 ;
28526 PyObject * obj0 = 0 ;
28527 PyObject * obj1 = 0 ;
28528 char * kwnames[] = {
28529 (char *) "self",(char *) "other", NULL
28530 };
28531
28532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28534 if (!SWIG_IsOK(res1)) {
28535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28536 }
28537 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28539 if (!SWIG_IsOK(res2)) {
28540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28541 }
28542 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 {
28550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28551 }
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28559 PyObject *resultobj = 0;
28560 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28561 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28562 bool result;
28563 void *argp1 = 0 ;
28564 int res1 = 0 ;
28565 void *argp2 = 0 ;
28566 int res2 = 0 ;
28567 PyObject * obj0 = 0 ;
28568 PyObject * obj1 = 0 ;
28569 char * kwnames[] = {
28570 (char *) "self",(char *) "other", NULL
28571 };
28572
28573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28575 if (!SWIG_IsOK(res1)) {
28576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28577 }
28578 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28580 if (!SWIG_IsOK(res2)) {
28581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28582 }
28583 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28584 {
28585 PyThreadState* __tstate = wxPyBeginAllowThreads();
28586 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 {
28591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28592 }
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28600 PyObject *resultobj = 0;
28601 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28602 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28603 bool result;
28604 void *argp1 = 0 ;
28605 int res1 = 0 ;
28606 void *argp2 = 0 ;
28607 int res2 = 0 ;
28608 PyObject * obj0 = 0 ;
28609 PyObject * obj1 = 0 ;
28610 char * kwnames[] = {
28611 (char *) "self",(char *) "other", NULL
28612 };
28613
28614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28616 if (!SWIG_IsOK(res1)) {
28617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28618 }
28619 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28620 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28621 if (!SWIG_IsOK(res2)) {
28622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28623 }
28624 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28625 {
28626 PyThreadState* __tstate = wxPyBeginAllowThreads();
28627 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28628 wxPyEndAllowThreads(__tstate);
28629 if (PyErr_Occurred()) SWIG_fail;
28630 }
28631 {
28632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28633 }
28634 return resultobj;
28635 fail:
28636 return NULL;
28637 }
28638
28639
28640 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28641 PyObject *resultobj = 0;
28642 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28643 bool result;
28644 void *argp1 = 0 ;
28645 int res1 = 0 ;
28646 PyObject *swig_obj[1] ;
28647
28648 if (!args) SWIG_fail;
28649 swig_obj[0] = args;
28650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28651 if (!SWIG_IsOK(res1)) {
28652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28653 }
28654 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 {
28662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28663 }
28664 return resultobj;
28665 fail:
28666 return NULL;
28667 }
28668
28669
28670 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28671 PyObject *resultobj = 0;
28672 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28673 bool result;
28674 void *argp1 = 0 ;
28675 int res1 = 0 ;
28676 PyObject *swig_obj[1] ;
28677
28678 if (!args) SWIG_fail;
28679 swig_obj[0] = args;
28680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28681 if (!SWIG_IsOK(res1)) {
28682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28683 }
28684 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28688 wxPyEndAllowThreads(__tstate);
28689 if (PyErr_Occurred()) SWIG_fail;
28690 }
28691 {
28692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28693 }
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28701 PyObject *resultobj = 0;
28702 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28703 bool result;
28704 void *argp1 = 0 ;
28705 int res1 = 0 ;
28706 PyObject *swig_obj[1] ;
28707
28708 if (!args) SWIG_fail;
28709 swig_obj[0] = args;
28710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28711 if (!SWIG_IsOK(res1)) {
28712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28713 }
28714 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 {
28722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28723 }
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28731 PyObject *resultobj = 0;
28732 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28733 wxTimeSpan *arg2 = 0 ;
28734 bool result;
28735 void *argp1 = 0 ;
28736 int res1 = 0 ;
28737 void *argp2 = 0 ;
28738 int res2 = 0 ;
28739 PyObject * obj0 = 0 ;
28740 PyObject * obj1 = 0 ;
28741 char * kwnames[] = {
28742 (char *) "self",(char *) "ts", NULL
28743 };
28744
28745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28747 if (!SWIG_IsOK(res1)) {
28748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28749 }
28750 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28751 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28752 if (!SWIG_IsOK(res2)) {
28753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28754 }
28755 if (!argp2) {
28756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28757 }
28758 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28759 {
28760 PyThreadState* __tstate = wxPyBeginAllowThreads();
28761 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28762 wxPyEndAllowThreads(__tstate);
28763 if (PyErr_Occurred()) SWIG_fail;
28764 }
28765 {
28766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28767 }
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj = 0;
28776 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28777 wxTimeSpan *arg2 = 0 ;
28778 bool result;
28779 void *argp1 = 0 ;
28780 int res1 = 0 ;
28781 void *argp2 = 0 ;
28782 int res2 = 0 ;
28783 PyObject * obj0 = 0 ;
28784 PyObject * obj1 = 0 ;
28785 char * kwnames[] = {
28786 (char *) "self",(char *) "ts", NULL
28787 };
28788
28789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28791 if (!SWIG_IsOK(res1)) {
28792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28793 }
28794 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28795 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28796 if (!SWIG_IsOK(res2)) {
28797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28798 }
28799 if (!argp2) {
28800 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28801 }
28802 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28803 {
28804 PyThreadState* __tstate = wxPyBeginAllowThreads();
28805 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28806 wxPyEndAllowThreads(__tstate);
28807 if (PyErr_Occurred()) SWIG_fail;
28808 }
28809 {
28810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28811 }
28812 return resultobj;
28813 fail:
28814 return NULL;
28815 }
28816
28817
28818 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28819 PyObject *resultobj = 0;
28820 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28821 wxTimeSpan *arg2 = 0 ;
28822 bool result;
28823 void *argp1 = 0 ;
28824 int res1 = 0 ;
28825 void *argp2 = 0 ;
28826 int res2 = 0 ;
28827 PyObject * obj0 = 0 ;
28828 PyObject * obj1 = 0 ;
28829 char * kwnames[] = {
28830 (char *) "self",(char *) "t", NULL
28831 };
28832
28833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28835 if (!SWIG_IsOK(res1)) {
28836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28837 }
28838 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28840 if (!SWIG_IsOK(res2)) {
28841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28842 }
28843 if (!argp2) {
28844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28845 }
28846 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28850 wxPyEndAllowThreads(__tstate);
28851 if (PyErr_Occurred()) SWIG_fail;
28852 }
28853 {
28854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28855 }
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28863 PyObject *resultobj = 0;
28864 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28865 int result;
28866 void *argp1 = 0 ;
28867 int res1 = 0 ;
28868 PyObject *swig_obj[1] ;
28869
28870 if (!args) SWIG_fail;
28871 swig_obj[0] = args;
28872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28875 }
28876 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_From_int(static_cast< int >(result));
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28891 PyObject *resultobj = 0;
28892 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28893 int result;
28894 void *argp1 = 0 ;
28895 int res1 = 0 ;
28896 PyObject *swig_obj[1] ;
28897
28898 if (!args) SWIG_fail;
28899 swig_obj[0] = args;
28900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28901 if (!SWIG_IsOK(res1)) {
28902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28903 }
28904 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28908 wxPyEndAllowThreads(__tstate);
28909 if (PyErr_Occurred()) SWIG_fail;
28910 }
28911 resultobj = SWIG_From_int(static_cast< int >(result));
28912 return resultobj;
28913 fail:
28914 return NULL;
28915 }
28916
28917
28918 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28919 PyObject *resultobj = 0;
28920 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28921 int result;
28922 void *argp1 = 0 ;
28923 int res1 = 0 ;
28924 PyObject *swig_obj[1] ;
28925
28926 if (!args) SWIG_fail;
28927 swig_obj[0] = args;
28928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28929 if (!SWIG_IsOK(res1)) {
28930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28931 }
28932 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28933 {
28934 PyThreadState* __tstate = wxPyBeginAllowThreads();
28935 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28936 wxPyEndAllowThreads(__tstate);
28937 if (PyErr_Occurred()) SWIG_fail;
28938 }
28939 resultobj = SWIG_From_int(static_cast< int >(result));
28940 return resultobj;
28941 fail:
28942 return NULL;
28943 }
28944
28945
28946 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28947 PyObject *resultobj = 0;
28948 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28949 int result;
28950 void *argp1 = 0 ;
28951 int res1 = 0 ;
28952 PyObject *swig_obj[1] ;
28953
28954 if (!args) SWIG_fail;
28955 swig_obj[0] = args;
28956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28957 if (!SWIG_IsOK(res1)) {
28958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28959 }
28960 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28961 {
28962 PyThreadState* __tstate = wxPyBeginAllowThreads();
28963 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28964 wxPyEndAllowThreads(__tstate);
28965 if (PyErr_Occurred()) SWIG_fail;
28966 }
28967 resultobj = SWIG_From_int(static_cast< int >(result));
28968 return resultobj;
28969 fail:
28970 return NULL;
28971 }
28972
28973
28974 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28975 PyObject *resultobj = 0;
28976 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28977 wxLongLong result;
28978 void *argp1 = 0 ;
28979 int res1 = 0 ;
28980 PyObject *swig_obj[1] ;
28981
28982 if (!args) SWIG_fail;
28983 swig_obj[0] = args;
28984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28985 if (!SWIG_IsOK(res1)) {
28986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28987 }
28988 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28989 {
28990 PyThreadState* __tstate = wxPyBeginAllowThreads();
28991 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28992 wxPyEndAllowThreads(__tstate);
28993 if (PyErr_Occurred()) SWIG_fail;
28994 }
28995 {
28996 PyObject *hi, *lo, *shifter, *shifted;
28997 hi = PyLong_FromLong( (&result)->GetHi() );
28998 lo = PyLong_FromLong( (&result)->GetLo() );
28999 shifter = PyLong_FromLong(32);
29000 shifted = PyNumber_Lshift(hi, shifter);
29001 resultobj = PyNumber_Or(shifted, lo);
29002 Py_DECREF(hi);
29003 Py_DECREF(lo);
29004 Py_DECREF(shifter);
29005 Py_DECREF(shifted);
29006 }
29007 return resultobj;
29008 fail:
29009 return NULL;
29010 }
29011
29012
29013 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29014 PyObject *resultobj = 0;
29015 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29016 wxLongLong result;
29017 void *argp1 = 0 ;
29018 int res1 = 0 ;
29019 PyObject *swig_obj[1] ;
29020
29021 if (!args) SWIG_fail;
29022 swig_obj[0] = args;
29023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29024 if (!SWIG_IsOK(res1)) {
29025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29026 }
29027 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29028 {
29029 PyThreadState* __tstate = wxPyBeginAllowThreads();
29030 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29031 wxPyEndAllowThreads(__tstate);
29032 if (PyErr_Occurred()) SWIG_fail;
29033 }
29034 {
29035 PyObject *hi, *lo, *shifter, *shifted;
29036 hi = PyLong_FromLong( (&result)->GetHi() );
29037 lo = PyLong_FromLong( (&result)->GetLo() );
29038 shifter = PyLong_FromLong(32);
29039 shifted = PyNumber_Lshift(hi, shifter);
29040 resultobj = PyNumber_Or(shifted, lo);
29041 Py_DECREF(hi);
29042 Py_DECREF(lo);
29043 Py_DECREF(shifter);
29044 Py_DECREF(shifted);
29045 }
29046 return resultobj;
29047 fail:
29048 return NULL;
29049 }
29050
29051
29052 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29053 PyObject *resultobj = 0;
29054 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29055 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29056 wxString *arg2 = (wxString *) &arg2_defvalue ;
29057 wxString result;
29058 void *argp1 = 0 ;
29059 int res1 = 0 ;
29060 bool temp2 = false ;
29061 PyObject * obj0 = 0 ;
29062 PyObject * obj1 = 0 ;
29063 char * kwnames[] = {
29064 (char *) "self",(char *) "format", NULL
29065 };
29066
29067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29069 if (!SWIG_IsOK(res1)) {
29070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29071 }
29072 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29073 if (obj1) {
29074 {
29075 arg2 = wxString_in_helper(obj1);
29076 if (arg2 == NULL) SWIG_fail;
29077 temp2 = true;
29078 }
29079 }
29080 {
29081 PyThreadState* __tstate = wxPyBeginAllowThreads();
29082 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 {
29087 #if wxUSE_UNICODE
29088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29089 #else
29090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29091 #endif
29092 }
29093 {
29094 if (temp2)
29095 delete arg2;
29096 }
29097 return resultobj;
29098 fail:
29099 {
29100 if (temp2)
29101 delete arg2;
29102 }
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 PyObject *obj;
29109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29110 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
29111 return SWIG_Py_Void();
29112 }
29113
29114 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29115 return SWIG_Python_InitShadowInstance(args);
29116 }
29117
29118 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29119 PyObject *resultobj = 0;
29120 int arg1 = (int) 0 ;
29121 int arg2 = (int) 0 ;
29122 int arg3 = (int) 0 ;
29123 int arg4 = (int) 0 ;
29124 wxDateSpan *result = 0 ;
29125 int val1 ;
29126 int ecode1 = 0 ;
29127 int val2 ;
29128 int ecode2 = 0 ;
29129 int val3 ;
29130 int ecode3 = 0 ;
29131 int val4 ;
29132 int ecode4 = 0 ;
29133 PyObject * obj0 = 0 ;
29134 PyObject * obj1 = 0 ;
29135 PyObject * obj2 = 0 ;
29136 PyObject * obj3 = 0 ;
29137 char * kwnames[] = {
29138 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
29139 };
29140
29141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29142 if (obj0) {
29143 ecode1 = SWIG_AsVal_int(obj0, &val1);
29144 if (!SWIG_IsOK(ecode1)) {
29145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
29146 }
29147 arg1 = static_cast< int >(val1);
29148 }
29149 if (obj1) {
29150 ecode2 = SWIG_AsVal_int(obj1, &val2);
29151 if (!SWIG_IsOK(ecode2)) {
29152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
29153 }
29154 arg2 = static_cast< int >(val2);
29155 }
29156 if (obj2) {
29157 ecode3 = SWIG_AsVal_int(obj2, &val3);
29158 if (!SWIG_IsOK(ecode3)) {
29159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
29160 }
29161 arg3 = static_cast< int >(val3);
29162 }
29163 if (obj3) {
29164 ecode4 = SWIG_AsVal_int(obj3, &val4);
29165 if (!SWIG_IsOK(ecode4)) {
29166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
29167 }
29168 arg4 = static_cast< int >(val4);
29169 }
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29184 PyObject *resultobj = 0;
29185 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29186 void *argp1 = 0 ;
29187 int res1 = 0 ;
29188 PyObject *swig_obj[1] ;
29189
29190 if (!args) SWIG_fail;
29191 swig_obj[0] = args;
29192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29193 if (!SWIG_IsOK(res1)) {
29194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29195 }
29196 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29197 {
29198 PyThreadState* __tstate = wxPyBeginAllowThreads();
29199 delete arg1;
29200
29201 wxPyEndAllowThreads(__tstate);
29202 if (PyErr_Occurred()) SWIG_fail;
29203 }
29204 resultobj = SWIG_Py_Void();
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29212 PyObject *resultobj = 0;
29213 int arg1 ;
29214 wxDateSpan result;
29215 int val1 ;
29216 int ecode1 = 0 ;
29217 PyObject * obj0 = 0 ;
29218 char * kwnames[] = {
29219 (char *) "days", NULL
29220 };
29221
29222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29223 ecode1 = SWIG_AsVal_int(obj0, &val1);
29224 if (!SWIG_IsOK(ecode1)) {
29225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29226 }
29227 arg1 = static_cast< int >(val1);
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 result = wxDateSpan::Days(arg1);
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29242 PyObject *resultobj = 0;
29243 wxDateSpan result;
29244
29245 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 result = wxDateSpan::Day();
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29260 PyObject *resultobj = 0;
29261 int arg1 ;
29262 wxDateSpan result;
29263 int val1 ;
29264 int ecode1 = 0 ;
29265 PyObject * obj0 = 0 ;
29266 char * kwnames[] = {
29267 (char *) "weeks", NULL
29268 };
29269
29270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29271 ecode1 = SWIG_AsVal_int(obj0, &val1);
29272 if (!SWIG_IsOK(ecode1)) {
29273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29274 }
29275 arg1 = static_cast< int >(val1);
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 result = wxDateSpan::Weeks(arg1);
29279 wxPyEndAllowThreads(__tstate);
29280 if (PyErr_Occurred()) SWIG_fail;
29281 }
29282 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29283 return resultobj;
29284 fail:
29285 return NULL;
29286 }
29287
29288
29289 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29290 PyObject *resultobj = 0;
29291 wxDateSpan result;
29292
29293 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29294 {
29295 PyThreadState* __tstate = wxPyBeginAllowThreads();
29296 result = wxDateSpan::Week();
29297 wxPyEndAllowThreads(__tstate);
29298 if (PyErr_Occurred()) SWIG_fail;
29299 }
29300 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29301 return resultobj;
29302 fail:
29303 return NULL;
29304 }
29305
29306
29307 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29308 PyObject *resultobj = 0;
29309 int arg1 ;
29310 wxDateSpan result;
29311 int val1 ;
29312 int ecode1 = 0 ;
29313 PyObject * obj0 = 0 ;
29314 char * kwnames[] = {
29315 (char *) "mon", NULL
29316 };
29317
29318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29319 ecode1 = SWIG_AsVal_int(obj0, &val1);
29320 if (!SWIG_IsOK(ecode1)) {
29321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29322 }
29323 arg1 = static_cast< int >(val1);
29324 {
29325 PyThreadState* __tstate = wxPyBeginAllowThreads();
29326 result = wxDateSpan::Months(arg1);
29327 wxPyEndAllowThreads(__tstate);
29328 if (PyErr_Occurred()) SWIG_fail;
29329 }
29330 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29331 return resultobj;
29332 fail:
29333 return NULL;
29334 }
29335
29336
29337 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29338 PyObject *resultobj = 0;
29339 wxDateSpan result;
29340
29341 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 result = wxDateSpan::Month();
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj = 0;
29357 int arg1 ;
29358 wxDateSpan result;
29359 int val1 ;
29360 int ecode1 = 0 ;
29361 PyObject * obj0 = 0 ;
29362 char * kwnames[] = {
29363 (char *) "years", NULL
29364 };
29365
29366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29367 ecode1 = SWIG_AsVal_int(obj0, &val1);
29368 if (!SWIG_IsOK(ecode1)) {
29369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29370 }
29371 arg1 = static_cast< int >(val1);
29372 {
29373 PyThreadState* __tstate = wxPyBeginAllowThreads();
29374 result = wxDateSpan::Years(arg1);
29375 wxPyEndAllowThreads(__tstate);
29376 if (PyErr_Occurred()) SWIG_fail;
29377 }
29378 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29379 return resultobj;
29380 fail:
29381 return NULL;
29382 }
29383
29384
29385 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29386 PyObject *resultobj = 0;
29387 wxDateSpan result;
29388
29389 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29390 {
29391 PyThreadState* __tstate = wxPyBeginAllowThreads();
29392 result = wxDateSpan::Year();
29393 wxPyEndAllowThreads(__tstate);
29394 if (PyErr_Occurred()) SWIG_fail;
29395 }
29396 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29397 return resultobj;
29398 fail:
29399 return NULL;
29400 }
29401
29402
29403 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29404 PyObject *resultobj = 0;
29405 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29406 int arg2 ;
29407 wxDateSpan *result = 0 ;
29408 void *argp1 = 0 ;
29409 int res1 = 0 ;
29410 int val2 ;
29411 int ecode2 = 0 ;
29412 PyObject * obj0 = 0 ;
29413 PyObject * obj1 = 0 ;
29414 char * kwnames[] = {
29415 (char *) "self",(char *) "n", NULL
29416 };
29417
29418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29420 if (!SWIG_IsOK(res1)) {
29421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29422 }
29423 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29424 ecode2 = SWIG_AsVal_int(obj1, &val2);
29425 if (!SWIG_IsOK(ecode2)) {
29426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29427 }
29428 arg2 = static_cast< int >(val2);
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 {
29432 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29433 result = (wxDateSpan *) &_result_ref;
29434 }
29435 wxPyEndAllowThreads(__tstate);
29436 if (PyErr_Occurred()) SWIG_fail;
29437 }
29438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj = 0;
29447 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29448 int arg2 ;
29449 wxDateSpan *result = 0 ;
29450 void *argp1 = 0 ;
29451 int res1 = 0 ;
29452 int val2 ;
29453 int ecode2 = 0 ;
29454 PyObject * obj0 = 0 ;
29455 PyObject * obj1 = 0 ;
29456 char * kwnames[] = {
29457 (char *) "self",(char *) "n", NULL
29458 };
29459
29460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29462 if (!SWIG_IsOK(res1)) {
29463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29464 }
29465 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29466 ecode2 = SWIG_AsVal_int(obj1, &val2);
29467 if (!SWIG_IsOK(ecode2)) {
29468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29469 }
29470 arg2 = static_cast< int >(val2);
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 {
29474 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29475 result = (wxDateSpan *) &_result_ref;
29476 }
29477 wxPyEndAllowThreads(__tstate);
29478 if (PyErr_Occurred()) SWIG_fail;
29479 }
29480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29481 return resultobj;
29482 fail:
29483 return NULL;
29484 }
29485
29486
29487 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29488 PyObject *resultobj = 0;
29489 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29490 int arg2 ;
29491 wxDateSpan *result = 0 ;
29492 void *argp1 = 0 ;
29493 int res1 = 0 ;
29494 int val2 ;
29495 int ecode2 = 0 ;
29496 PyObject * obj0 = 0 ;
29497 PyObject * obj1 = 0 ;
29498 char * kwnames[] = {
29499 (char *) "self",(char *) "n", NULL
29500 };
29501
29502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29504 if (!SWIG_IsOK(res1)) {
29505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29506 }
29507 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29508 ecode2 = SWIG_AsVal_int(obj1, &val2);
29509 if (!SWIG_IsOK(ecode2)) {
29510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29511 }
29512 arg2 = static_cast< int >(val2);
29513 {
29514 PyThreadState* __tstate = wxPyBeginAllowThreads();
29515 {
29516 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29517 result = (wxDateSpan *) &_result_ref;
29518 }
29519 wxPyEndAllowThreads(__tstate);
29520 if (PyErr_Occurred()) SWIG_fail;
29521 }
29522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj = 0;
29531 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29532 int arg2 ;
29533 wxDateSpan *result = 0 ;
29534 void *argp1 = 0 ;
29535 int res1 = 0 ;
29536 int val2 ;
29537 int ecode2 = 0 ;
29538 PyObject * obj0 = 0 ;
29539 PyObject * obj1 = 0 ;
29540 char * kwnames[] = {
29541 (char *) "self",(char *) "n", NULL
29542 };
29543
29544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29546 if (!SWIG_IsOK(res1)) {
29547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29548 }
29549 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29550 ecode2 = SWIG_AsVal_int(obj1, &val2);
29551 if (!SWIG_IsOK(ecode2)) {
29552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29553 }
29554 arg2 = static_cast< int >(val2);
29555 {
29556 PyThreadState* __tstate = wxPyBeginAllowThreads();
29557 {
29558 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29559 result = (wxDateSpan *) &_result_ref;
29560 }
29561 wxPyEndAllowThreads(__tstate);
29562 if (PyErr_Occurred()) SWIG_fail;
29563 }
29564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29565 return resultobj;
29566 fail:
29567 return NULL;
29568 }
29569
29570
29571 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29572 PyObject *resultobj = 0;
29573 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29574 int result;
29575 void *argp1 = 0 ;
29576 int res1 = 0 ;
29577 PyObject *swig_obj[1] ;
29578
29579 if (!args) SWIG_fail;
29580 swig_obj[0] = args;
29581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29582 if (!SWIG_IsOK(res1)) {
29583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29584 }
29585 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29586 {
29587 PyThreadState* __tstate = wxPyBeginAllowThreads();
29588 result = (int)((wxDateSpan const *)arg1)->GetYears();
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 resultobj = SWIG_From_int(static_cast< int >(result));
29593 return resultobj;
29594 fail:
29595 return NULL;
29596 }
29597
29598
29599 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29600 PyObject *resultobj = 0;
29601 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29602 int result;
29603 void *argp1 = 0 ;
29604 int res1 = 0 ;
29605 PyObject *swig_obj[1] ;
29606
29607 if (!args) SWIG_fail;
29608 swig_obj[0] = args;
29609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29612 }
29613 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29614 {
29615 PyThreadState* __tstate = wxPyBeginAllowThreads();
29616 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29617 wxPyEndAllowThreads(__tstate);
29618 if (PyErr_Occurred()) SWIG_fail;
29619 }
29620 resultobj = SWIG_From_int(static_cast< int >(result));
29621 return resultobj;
29622 fail:
29623 return NULL;
29624 }
29625
29626
29627 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29628 PyObject *resultobj = 0;
29629 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29630 int result;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 PyObject *swig_obj[1] ;
29634
29635 if (!args) SWIG_fail;
29636 swig_obj[0] = args;
29637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29638 if (!SWIG_IsOK(res1)) {
29639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29640 }
29641 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 resultobj = SWIG_From_int(static_cast< int >(result));
29649 return resultobj;
29650 fail:
29651 return NULL;
29652 }
29653
29654
29655 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29656 PyObject *resultobj = 0;
29657 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29658 int result;
29659 void *argp1 = 0 ;
29660 int res1 = 0 ;
29661 PyObject *swig_obj[1] ;
29662
29663 if (!args) SWIG_fail;
29664 swig_obj[0] = args;
29665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29666 if (!SWIG_IsOK(res1)) {
29667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29668 }
29669 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29670 {
29671 PyThreadState* __tstate = wxPyBeginAllowThreads();
29672 result = (int)((wxDateSpan const *)arg1)->GetDays();
29673 wxPyEndAllowThreads(__tstate);
29674 if (PyErr_Occurred()) SWIG_fail;
29675 }
29676 resultobj = SWIG_From_int(static_cast< int >(result));
29677 return resultobj;
29678 fail:
29679 return NULL;
29680 }
29681
29682
29683 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29684 PyObject *resultobj = 0;
29685 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29686 int result;
29687 void *argp1 = 0 ;
29688 int res1 = 0 ;
29689 PyObject *swig_obj[1] ;
29690
29691 if (!args) SWIG_fail;
29692 swig_obj[0] = args;
29693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29694 if (!SWIG_IsOK(res1)) {
29695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29696 }
29697 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29698 {
29699 PyThreadState* __tstate = wxPyBeginAllowThreads();
29700 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29701 wxPyEndAllowThreads(__tstate);
29702 if (PyErr_Occurred()) SWIG_fail;
29703 }
29704 resultobj = SWIG_From_int(static_cast< int >(result));
29705 return resultobj;
29706 fail:
29707 return NULL;
29708 }
29709
29710
29711 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29712 PyObject *resultobj = 0;
29713 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29714 wxDateSpan *arg2 = 0 ;
29715 wxDateSpan *result = 0 ;
29716 void *argp1 = 0 ;
29717 int res1 = 0 ;
29718 void *argp2 = 0 ;
29719 int res2 = 0 ;
29720 PyObject * obj0 = 0 ;
29721 PyObject * obj1 = 0 ;
29722 char * kwnames[] = {
29723 (char *) "self",(char *) "other", NULL
29724 };
29725
29726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29728 if (!SWIG_IsOK(res1)) {
29729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29730 }
29731 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29733 if (!SWIG_IsOK(res2)) {
29734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29735 }
29736 if (!argp2) {
29737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29738 }
29739 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29740 {
29741 PyThreadState* __tstate = wxPyBeginAllowThreads();
29742 {
29743 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29744 result = (wxDateSpan *) &_result_ref;
29745 }
29746 wxPyEndAllowThreads(__tstate);
29747 if (PyErr_Occurred()) SWIG_fail;
29748 }
29749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29750 return resultobj;
29751 fail:
29752 return NULL;
29753 }
29754
29755
29756 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29757 PyObject *resultobj = 0;
29758 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29759 wxDateSpan *arg2 = 0 ;
29760 wxDateSpan *result = 0 ;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 void *argp2 = 0 ;
29764 int res2 = 0 ;
29765 PyObject * obj0 = 0 ;
29766 PyObject * obj1 = 0 ;
29767 char * kwnames[] = {
29768 (char *) "self",(char *) "other", NULL
29769 };
29770
29771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29773 if (!SWIG_IsOK(res1)) {
29774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29775 }
29776 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29777 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29778 if (!SWIG_IsOK(res2)) {
29779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29780 }
29781 if (!argp2) {
29782 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29783 }
29784 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29785 {
29786 PyThreadState* __tstate = wxPyBeginAllowThreads();
29787 {
29788 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29789 result = (wxDateSpan *) &_result_ref;
29790 }
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29802 PyObject *resultobj = 0;
29803 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29804 wxDateSpan *result = 0 ;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 PyObject *swig_obj[1] ;
29808
29809 if (!args) SWIG_fail;
29810 swig_obj[0] = args;
29811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29812 if (!SWIG_IsOK(res1)) {
29813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29814 }
29815 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29816 {
29817 PyThreadState* __tstate = wxPyBeginAllowThreads();
29818 {
29819 wxDateSpan &_result_ref = (arg1)->Neg();
29820 result = (wxDateSpan *) &_result_ref;
29821 }
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29826 return resultobj;
29827 fail:
29828 return NULL;
29829 }
29830
29831
29832 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29833 PyObject *resultobj = 0;
29834 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29835 int arg2 ;
29836 wxDateSpan *result = 0 ;
29837 void *argp1 = 0 ;
29838 int res1 = 0 ;
29839 int val2 ;
29840 int ecode2 = 0 ;
29841 PyObject * obj0 = 0 ;
29842 PyObject * obj1 = 0 ;
29843 char * kwnames[] = {
29844 (char *) "self",(char *) "factor", NULL
29845 };
29846
29847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29849 if (!SWIG_IsOK(res1)) {
29850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29851 }
29852 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29853 ecode2 = SWIG_AsVal_int(obj1, &val2);
29854 if (!SWIG_IsOK(ecode2)) {
29855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29856 }
29857 arg2 = static_cast< int >(val2);
29858 {
29859 PyThreadState* __tstate = wxPyBeginAllowThreads();
29860 {
29861 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29862 result = (wxDateSpan *) &_result_ref;
29863 }
29864 wxPyEndAllowThreads(__tstate);
29865 if (PyErr_Occurred()) SWIG_fail;
29866 }
29867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj = 0;
29876 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29877 wxDateSpan *arg2 = 0 ;
29878 wxDateSpan *result = 0 ;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 void *argp2 = 0 ;
29882 int res2 = 0 ;
29883 PyObject * obj0 = 0 ;
29884 PyObject * obj1 = 0 ;
29885 char * kwnames[] = {
29886 (char *) "self",(char *) "other", NULL
29887 };
29888
29889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29891 if (!SWIG_IsOK(res1)) {
29892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29893 }
29894 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29895 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29896 if (!SWIG_IsOK(res2)) {
29897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29898 }
29899 if (!argp2) {
29900 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29901 }
29902 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29903 {
29904 PyThreadState* __tstate = wxPyBeginAllowThreads();
29905 {
29906 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29907 result = (wxDateSpan *) &_result_ref;
29908 }
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29920 PyObject *resultobj = 0;
29921 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29922 wxDateSpan *arg2 = 0 ;
29923 wxDateSpan *result = 0 ;
29924 void *argp1 = 0 ;
29925 int res1 = 0 ;
29926 void *argp2 = 0 ;
29927 int res2 = 0 ;
29928 PyObject * obj0 = 0 ;
29929 PyObject * obj1 = 0 ;
29930 char * kwnames[] = {
29931 (char *) "self",(char *) "other", NULL
29932 };
29933
29934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29936 if (!SWIG_IsOK(res1)) {
29937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29938 }
29939 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29940 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29941 if (!SWIG_IsOK(res2)) {
29942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29943 }
29944 if (!argp2) {
29945 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29946 }
29947 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29948 {
29949 PyThreadState* __tstate = wxPyBeginAllowThreads();
29950 {
29951 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29952 result = (wxDateSpan *) &_result_ref;
29953 }
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29958 return resultobj;
29959 fail:
29960 return NULL;
29961 }
29962
29963
29964 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29965 PyObject *resultobj = 0;
29966 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29967 wxDateSpan *result = 0 ;
29968 void *argp1 = 0 ;
29969 int res1 = 0 ;
29970 PyObject *swig_obj[1] ;
29971
29972 if (!args) SWIG_fail;
29973 swig_obj[0] = args;
29974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29975 if (!SWIG_IsOK(res1)) {
29976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29977 }
29978 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29979 {
29980 PyThreadState* __tstate = wxPyBeginAllowThreads();
29981 {
29982 wxDateSpan &_result_ref = (arg1)->operator -();
29983 result = (wxDateSpan *) &_result_ref;
29984 }
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29996 PyObject *resultobj = 0;
29997 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29998 int arg2 ;
29999 wxDateSpan *result = 0 ;
30000 void *argp1 = 0 ;
30001 int res1 = 0 ;
30002 int val2 ;
30003 int ecode2 = 0 ;
30004 PyObject * obj0 = 0 ;
30005 PyObject * obj1 = 0 ;
30006 char * kwnames[] = {
30007 (char *) "self",(char *) "factor", NULL
30008 };
30009
30010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30012 if (!SWIG_IsOK(res1)) {
30013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30014 }
30015 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30016 ecode2 = SWIG_AsVal_int(obj1, &val2);
30017 if (!SWIG_IsOK(ecode2)) {
30018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30019 }
30020 arg2 = static_cast< int >(val2);
30021 {
30022 PyThreadState* __tstate = wxPyBeginAllowThreads();
30023 {
30024 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30025 result = (wxDateSpan *) &_result_ref;
30026 }
30027 wxPyEndAllowThreads(__tstate);
30028 if (PyErr_Occurred()) SWIG_fail;
30029 }
30030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30031 return resultobj;
30032 fail:
30033 return NULL;
30034 }
30035
30036
30037 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30038 PyObject *resultobj = 0;
30039 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30040 wxDateSpan *arg2 = 0 ;
30041 wxDateSpan result;
30042 void *argp1 = 0 ;
30043 int res1 = 0 ;
30044 void *argp2 = 0 ;
30045 int res2 = 0 ;
30046 PyObject * obj0 = 0 ;
30047 PyObject * obj1 = 0 ;
30048 char * kwnames[] = {
30049 (char *) "self",(char *) "other", NULL
30050 };
30051
30052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30054 if (!SWIG_IsOK(res1)) {
30055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30056 }
30057 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30058 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30059 if (!SWIG_IsOK(res2)) {
30060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30061 }
30062 if (!argp2) {
30063 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30064 }
30065 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30066 {
30067 PyThreadState* __tstate = wxPyBeginAllowThreads();
30068 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30069 wxPyEndAllowThreads(__tstate);
30070 if (PyErr_Occurred()) SWIG_fail;
30071 }
30072 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30073 return resultobj;
30074 fail:
30075 return NULL;
30076 }
30077
30078
30079 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30080 PyObject *resultobj = 0;
30081 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30082 wxDateSpan *arg2 = 0 ;
30083 wxDateSpan result;
30084 void *argp1 = 0 ;
30085 int res1 = 0 ;
30086 void *argp2 = 0 ;
30087 int res2 = 0 ;
30088 PyObject * obj0 = 0 ;
30089 PyObject * obj1 = 0 ;
30090 char * kwnames[] = {
30091 (char *) "self",(char *) "other", NULL
30092 };
30093
30094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30096 if (!SWIG_IsOK(res1)) {
30097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30098 }
30099 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30100 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30101 if (!SWIG_IsOK(res2)) {
30102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30103 }
30104 if (!argp2) {
30105 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30106 }
30107 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30108 {
30109 PyThreadState* __tstate = wxPyBeginAllowThreads();
30110 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30115 return resultobj;
30116 fail:
30117 return NULL;
30118 }
30119
30120
30121 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30122 PyObject *resultobj = 0;
30123 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30124 int arg2 ;
30125 wxDateSpan result;
30126 void *argp1 = 0 ;
30127 int res1 = 0 ;
30128 int val2 ;
30129 int ecode2 = 0 ;
30130 PyObject * obj0 = 0 ;
30131 PyObject * obj1 = 0 ;
30132 char * kwnames[] = {
30133 (char *) "self",(char *) "n", NULL
30134 };
30135
30136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
30137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30138 if (!SWIG_IsOK(res1)) {
30139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30140 }
30141 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30142 ecode2 = SWIG_AsVal_int(obj1, &val2);
30143 if (!SWIG_IsOK(ecode2)) {
30144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
30145 }
30146 arg2 = static_cast< int >(val2);
30147 {
30148 PyThreadState* __tstate = wxPyBeginAllowThreads();
30149 result = wxDateSpan___mul__(arg1,arg2);
30150 wxPyEndAllowThreads(__tstate);
30151 if (PyErr_Occurred()) SWIG_fail;
30152 }
30153 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30154 return resultobj;
30155 fail:
30156 return NULL;
30157 }
30158
30159
30160 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30161 PyObject *resultobj = 0;
30162 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30163 int arg2 ;
30164 wxDateSpan result;
30165 void *argp1 = 0 ;
30166 int res1 = 0 ;
30167 int val2 ;
30168 int ecode2 = 0 ;
30169 PyObject * obj0 = 0 ;
30170 PyObject * obj1 = 0 ;
30171 char * kwnames[] = {
30172 (char *) "self",(char *) "n", NULL
30173 };
30174
30175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30177 if (!SWIG_IsOK(res1)) {
30178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30179 }
30180 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30181 ecode2 = SWIG_AsVal_int(obj1, &val2);
30182 if (!SWIG_IsOK(ecode2)) {
30183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30184 }
30185 arg2 = static_cast< int >(val2);
30186 {
30187 PyThreadState* __tstate = wxPyBeginAllowThreads();
30188 result = wxDateSpan___rmul__(arg1,arg2);
30189 wxPyEndAllowThreads(__tstate);
30190 if (PyErr_Occurred()) SWIG_fail;
30191 }
30192 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30193 return resultobj;
30194 fail:
30195 return NULL;
30196 }
30197
30198
30199 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30200 PyObject *resultobj = 0;
30201 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30202 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30203 bool result;
30204 void *argp1 = 0 ;
30205 int res1 = 0 ;
30206 void *argp2 = 0 ;
30207 int res2 = 0 ;
30208 PyObject * obj0 = 0 ;
30209 PyObject * obj1 = 0 ;
30210 char * kwnames[] = {
30211 (char *) "self",(char *) "other", NULL
30212 };
30213
30214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30216 if (!SWIG_IsOK(res1)) {
30217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30218 }
30219 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30221 if (!SWIG_IsOK(res2)) {
30222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30223 }
30224 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 {
30232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30233 }
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30241 PyObject *resultobj = 0;
30242 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30243 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30244 bool result;
30245 void *argp1 = 0 ;
30246 int res1 = 0 ;
30247 void *argp2 = 0 ;
30248 int res2 = 0 ;
30249 PyObject * obj0 = 0 ;
30250 PyObject * obj1 = 0 ;
30251 char * kwnames[] = {
30252 (char *) "self",(char *) "other", NULL
30253 };
30254
30255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30257 if (!SWIG_IsOK(res1)) {
30258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30259 }
30260 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30262 if (!SWIG_IsOK(res2)) {
30263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30264 }
30265 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30269 wxPyEndAllowThreads(__tstate);
30270 if (PyErr_Occurred()) SWIG_fail;
30271 }
30272 {
30273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30274 }
30275 return resultobj;
30276 fail:
30277 return NULL;
30278 }
30279
30280
30281 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30282 PyObject *obj;
30283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30284 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30285 return SWIG_Py_Void();
30286 }
30287
30288 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30289 return SWIG_Python_InitShadowInstance(args);
30290 }
30291
30292 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30293 PyObject *resultobj = 0;
30294 long result;
30295
30296 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 result = (long)wxGetLocalTime();
30300 wxPyEndAllowThreads(__tstate);
30301 if (PyErr_Occurred()) SWIG_fail;
30302 }
30303 resultobj = SWIG_From_long(static_cast< long >(result));
30304 return resultobj;
30305 fail:
30306 return NULL;
30307 }
30308
30309
30310 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30311 PyObject *resultobj = 0;
30312 long result;
30313
30314 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30315 {
30316 PyThreadState* __tstate = wxPyBeginAllowThreads();
30317 result = (long)wxGetUTCTime();
30318 wxPyEndAllowThreads(__tstate);
30319 if (PyErr_Occurred()) SWIG_fail;
30320 }
30321 resultobj = SWIG_From_long(static_cast< long >(result));
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30329 PyObject *resultobj = 0;
30330 long result;
30331
30332 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30333 {
30334 PyThreadState* __tstate = wxPyBeginAllowThreads();
30335 result = (long)wxGetCurrentTime();
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 resultobj = SWIG_From_long(static_cast< long >(result));
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30347 PyObject *resultobj = 0;
30348 wxLongLong result;
30349
30350 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 result = wxGetLocalTimeMillis();
30354 wxPyEndAllowThreads(__tstate);
30355 if (PyErr_Occurred()) SWIG_fail;
30356 }
30357 {
30358 PyObject *hi, *lo, *shifter, *shifted;
30359 hi = PyLong_FromLong( (&result)->GetHi() );
30360 lo = PyLong_FromLong( (&result)->GetLo() );
30361 shifter = PyLong_FromLong(32);
30362 shifted = PyNumber_Lshift(hi, shifter);
30363 resultobj = PyNumber_Or(shifted, lo);
30364 Py_DECREF(hi);
30365 Py_DECREF(lo);
30366 Py_DECREF(shifter);
30367 Py_DECREF(shifted);
30368 }
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30376 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30377 return 1;
30378 }
30379
30380
30381 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30382 PyObject *pyobj = 0;
30383
30384 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30385 return pyobj;
30386 }
30387
30388
30389 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30390 PyObject *resultobj = 0;
30391 wxDataFormatId arg1 ;
30392 wxDataFormat *result = 0 ;
30393 int val1 ;
30394 int ecode1 = 0 ;
30395 PyObject * obj0 = 0 ;
30396 char * kwnames[] = {
30397 (char *) "type", NULL
30398 };
30399
30400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30401 ecode1 = SWIG_AsVal_int(obj0, &val1);
30402 if (!SWIG_IsOK(ecode1)) {
30403 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30404 }
30405 arg1 = static_cast< wxDataFormatId >(val1);
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 result = (wxDataFormat *)new wxDataFormat(arg1);
30409 wxPyEndAllowThreads(__tstate);
30410 if (PyErr_Occurred()) SWIG_fail;
30411 }
30412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30413 return resultobj;
30414 fail:
30415 return NULL;
30416 }
30417
30418
30419 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30420 PyObject *resultobj = 0;
30421 wxString *arg1 = 0 ;
30422 wxDataFormat *result = 0 ;
30423 bool temp1 = false ;
30424 PyObject * obj0 = 0 ;
30425 char * kwnames[] = {
30426 (char *) "format", NULL
30427 };
30428
30429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30430 {
30431 arg1 = wxString_in_helper(obj0);
30432 if (arg1 == NULL) SWIG_fail;
30433 temp1 = true;
30434 }
30435 {
30436 PyThreadState* __tstate = wxPyBeginAllowThreads();
30437 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30438 wxPyEndAllowThreads(__tstate);
30439 if (PyErr_Occurred()) SWIG_fail;
30440 }
30441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30442 {
30443 if (temp1)
30444 delete arg1;
30445 }
30446 return resultobj;
30447 fail:
30448 {
30449 if (temp1)
30450 delete arg1;
30451 }
30452 return NULL;
30453 }
30454
30455
30456 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30457 PyObject *resultobj = 0;
30458 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30459 void *argp1 = 0 ;
30460 int res1 = 0 ;
30461 PyObject *swig_obj[1] ;
30462
30463 if (!args) SWIG_fail;
30464 swig_obj[0] = args;
30465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30466 if (!SWIG_IsOK(res1)) {
30467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30468 }
30469 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 delete arg1;
30473
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 resultobj = SWIG_Py_Void();
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30485 PyObject *resultobj = 0;
30486 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30487 wxDataFormatId arg2 ;
30488 bool result;
30489 void *argp1 = 0 ;
30490 int res1 = 0 ;
30491 int val2 ;
30492 int ecode2 = 0 ;
30493
30494 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30496 if (!SWIG_IsOK(res1)) {
30497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30498 }
30499 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30500 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30501 if (!SWIG_IsOK(ecode2)) {
30502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30503 }
30504 arg2 = static_cast< wxDataFormatId >(val2);
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 {
30512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30513 }
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30521 PyObject *resultobj = 0;
30522 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30523 wxDataFormatId arg2 ;
30524 bool result;
30525 void *argp1 = 0 ;
30526 int res1 = 0 ;
30527 int val2 ;
30528 int ecode2 = 0 ;
30529
30530 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30532 if (!SWIG_IsOK(res1)) {
30533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30534 }
30535 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30536 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30537 if (!SWIG_IsOK(ecode2)) {
30538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30539 }
30540 arg2 = static_cast< wxDataFormatId >(val2);
30541 {
30542 PyThreadState* __tstate = wxPyBeginAllowThreads();
30543 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30544 wxPyEndAllowThreads(__tstate);
30545 if (PyErr_Occurred()) SWIG_fail;
30546 }
30547 {
30548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30549 }
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30557 PyObject *resultobj = 0;
30558 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30559 wxDataFormat *arg2 = 0 ;
30560 bool result;
30561 void *argp1 = 0 ;
30562 int res1 = 0 ;
30563 void *argp2 = 0 ;
30564 int res2 = 0 ;
30565
30566 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30568 if (!SWIG_IsOK(res1)) {
30569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30570 }
30571 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30572 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30573 if (!SWIG_IsOK(res2)) {
30574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30575 }
30576 if (!argp2) {
30577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30578 }
30579 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30580 {
30581 PyThreadState* __tstate = wxPyBeginAllowThreads();
30582 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30583 wxPyEndAllowThreads(__tstate);
30584 if (PyErr_Occurred()) SWIG_fail;
30585 }
30586 {
30587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30588 }
30589 return resultobj;
30590 fail:
30591 return NULL;
30592 }
30593
30594
30595 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30596 int argc;
30597 PyObject *argv[3];
30598
30599 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30600 --argc;
30601 if (argc == 2) {
30602 int _v = 0;
30603 {
30604 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30605 _v = SWIG_CheckState(res);
30606 }
30607 if (!_v) goto check_1;
30608 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30609 }
30610 check_1:
30611
30612 if (argc == 2) {
30613 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30614 }
30615
30616 fail:
30617 Py_INCREF(Py_NotImplemented);
30618 return Py_NotImplemented;
30619 }
30620
30621
30622 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30623 PyObject *resultobj = 0;
30624 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30625 wxDataFormat *arg2 = 0 ;
30626 bool result;
30627 void *argp1 = 0 ;
30628 int res1 = 0 ;
30629 void *argp2 = 0 ;
30630 int res2 = 0 ;
30631
30632 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30634 if (!SWIG_IsOK(res1)) {
30635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30636 }
30637 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30638 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30639 if (!SWIG_IsOK(res2)) {
30640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30641 }
30642 if (!argp2) {
30643 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30644 }
30645 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30646 {
30647 PyThreadState* __tstate = wxPyBeginAllowThreads();
30648 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30649 wxPyEndAllowThreads(__tstate);
30650 if (PyErr_Occurred()) SWIG_fail;
30651 }
30652 {
30653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30654 }
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30662 int argc;
30663 PyObject *argv[3];
30664
30665 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30666 --argc;
30667 if (argc == 2) {
30668 int _v = 0;
30669 {
30670 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30671 _v = SWIG_CheckState(res);
30672 }
30673 if (!_v) goto check_1;
30674 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30675 }
30676 check_1:
30677
30678 if (argc == 2) {
30679 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30680 }
30681
30682 fail:
30683 Py_INCREF(Py_NotImplemented);
30684 return Py_NotImplemented;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30689 PyObject *resultobj = 0;
30690 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30691 wxDataFormatId arg2 ;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 int val2 ;
30695 int ecode2 = 0 ;
30696 PyObject * obj0 = 0 ;
30697 PyObject * obj1 = 0 ;
30698 char * kwnames[] = {
30699 (char *) "self",(char *) "format", NULL
30700 };
30701
30702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30704 if (!SWIG_IsOK(res1)) {
30705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30706 }
30707 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30708 ecode2 = SWIG_AsVal_int(obj1, &val2);
30709 if (!SWIG_IsOK(ecode2)) {
30710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30711 }
30712 arg2 = static_cast< wxDataFormatId >(val2);
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 (arg1)->SetType(arg2);
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 resultobj = SWIG_Py_Void();
30720 return resultobj;
30721 fail:
30722 return NULL;
30723 }
30724
30725
30726 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30727 PyObject *resultobj = 0;
30728 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30729 wxDataFormatId result;
30730 void *argp1 = 0 ;
30731 int res1 = 0 ;
30732 PyObject *swig_obj[1] ;
30733
30734 if (!args) SWIG_fail;
30735 swig_obj[0] = args;
30736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30737 if (!SWIG_IsOK(res1)) {
30738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30739 }
30740 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30741 {
30742 PyThreadState* __tstate = wxPyBeginAllowThreads();
30743 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30744 wxPyEndAllowThreads(__tstate);
30745 if (PyErr_Occurred()) SWIG_fail;
30746 }
30747 resultobj = SWIG_From_int(static_cast< int >(result));
30748 return resultobj;
30749 fail:
30750 return NULL;
30751 }
30752
30753
30754 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30755 PyObject *resultobj = 0;
30756 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30757 wxString result;
30758 void *argp1 = 0 ;
30759 int res1 = 0 ;
30760 PyObject *swig_obj[1] ;
30761
30762 if (!args) SWIG_fail;
30763 swig_obj[0] = args;
30764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30765 if (!SWIG_IsOK(res1)) {
30766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30767 }
30768 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30769 {
30770 PyThreadState* __tstate = wxPyBeginAllowThreads();
30771 result = ((wxDataFormat const *)arg1)->GetId();
30772 wxPyEndAllowThreads(__tstate);
30773 if (PyErr_Occurred()) SWIG_fail;
30774 }
30775 {
30776 #if wxUSE_UNICODE
30777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30778 #else
30779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30780 #endif
30781 }
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj = 0;
30790 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30791 wxString *arg2 = 0 ;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 bool temp2 = false ;
30795 PyObject * obj0 = 0 ;
30796 PyObject * obj1 = 0 ;
30797 char * kwnames[] = {
30798 (char *) "self",(char *) "format", NULL
30799 };
30800
30801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30803 if (!SWIG_IsOK(res1)) {
30804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30805 }
30806 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30807 {
30808 arg2 = wxString_in_helper(obj1);
30809 if (arg2 == NULL) SWIG_fail;
30810 temp2 = true;
30811 }
30812 {
30813 PyThreadState* __tstate = wxPyBeginAllowThreads();
30814 (arg1)->SetId((wxString const &)*arg2);
30815 wxPyEndAllowThreads(__tstate);
30816 if (PyErr_Occurred()) SWIG_fail;
30817 }
30818 resultobj = SWIG_Py_Void();
30819 {
30820 if (temp2)
30821 delete arg2;
30822 }
30823 return resultobj;
30824 fail:
30825 {
30826 if (temp2)
30827 delete arg2;
30828 }
30829 return NULL;
30830 }
30831
30832
30833 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30834 PyObject *obj;
30835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30836 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30837 return SWIG_Py_Void();
30838 }
30839
30840 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30841 return SWIG_Python_InitShadowInstance(args);
30842 }
30843
30844 SWIGINTERN int FormatInvalid_set(PyObject *) {
30845 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30846 return 1;
30847 }
30848
30849
30850 SWIGINTERN PyObject *FormatInvalid_get(void) {
30851 PyObject *pyobj = 0;
30852
30853 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30854 return pyobj;
30855 }
30856
30857
30858 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30859 PyObject *resultobj = 0;
30860 wxDataObject *arg1 = (wxDataObject *) 0 ;
30861 void *argp1 = 0 ;
30862 int res1 = 0 ;
30863 PyObject *swig_obj[1] ;
30864
30865 if (!args) SWIG_fail;
30866 swig_obj[0] = args;
30867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30868 if (!SWIG_IsOK(res1)) {
30869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30870 }
30871 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30872 {
30873 PyThreadState* __tstate = wxPyBeginAllowThreads();
30874 delete arg1;
30875
30876 wxPyEndAllowThreads(__tstate);
30877 if (PyErr_Occurred()) SWIG_fail;
30878 }
30879 resultobj = SWIG_Py_Void();
30880 return resultobj;
30881 fail:
30882 return NULL;
30883 }
30884
30885
30886 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30887 PyObject *resultobj = 0;
30888 wxDataObject *arg1 = (wxDataObject *) 0 ;
30889 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30890 SwigValueWrapper<wxDataFormat > result;
30891 void *argp1 = 0 ;
30892 int res1 = 0 ;
30893 int val2 ;
30894 int ecode2 = 0 ;
30895 PyObject * obj0 = 0 ;
30896 PyObject * obj1 = 0 ;
30897 char * kwnames[] = {
30898 (char *) "self",(char *) "dir", NULL
30899 };
30900
30901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30903 if (!SWIG_IsOK(res1)) {
30904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30905 }
30906 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30907 if (obj1) {
30908 ecode2 = SWIG_AsVal_int(obj1, &val2);
30909 if (!SWIG_IsOK(ecode2)) {
30910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30911 }
30912 arg2 = static_cast< wxDataObject::Direction >(val2);
30913 }
30914 {
30915 PyThreadState* __tstate = wxPyBeginAllowThreads();
30916 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30921 return resultobj;
30922 fail:
30923 return NULL;
30924 }
30925
30926
30927 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30928 PyObject *resultobj = 0;
30929 wxDataObject *arg1 = (wxDataObject *) 0 ;
30930 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30931 size_t result;
30932 void *argp1 = 0 ;
30933 int res1 = 0 ;
30934 int val2 ;
30935 int ecode2 = 0 ;
30936 PyObject * obj0 = 0 ;
30937 PyObject * obj1 = 0 ;
30938 char * kwnames[] = {
30939 (char *) "self",(char *) "dir", NULL
30940 };
30941
30942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30944 if (!SWIG_IsOK(res1)) {
30945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30946 }
30947 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30948 if (obj1) {
30949 ecode2 = SWIG_AsVal_int(obj1, &val2);
30950 if (!SWIG_IsOK(ecode2)) {
30951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30952 }
30953 arg2 = static_cast< wxDataObject::Direction >(val2);
30954 }
30955 {
30956 PyThreadState* __tstate = wxPyBeginAllowThreads();
30957 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30958 wxPyEndAllowThreads(__tstate);
30959 if (PyErr_Occurred()) SWIG_fail;
30960 }
30961 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30962 return resultobj;
30963 fail:
30964 return NULL;
30965 }
30966
30967
30968 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30969 PyObject *resultobj = 0;
30970 wxDataObject *arg1 = (wxDataObject *) 0 ;
30971 wxDataFormat *arg2 = 0 ;
30972 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30973 bool result;
30974 void *argp1 = 0 ;
30975 int res1 = 0 ;
30976 void *argp2 = 0 ;
30977 int res2 = 0 ;
30978 int val3 ;
30979 int ecode3 = 0 ;
30980 PyObject * obj0 = 0 ;
30981 PyObject * obj1 = 0 ;
30982 PyObject * obj2 = 0 ;
30983 char * kwnames[] = {
30984 (char *) "self",(char *) "format",(char *) "dir", NULL
30985 };
30986
30987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30989 if (!SWIG_IsOK(res1)) {
30990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30991 }
30992 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30994 if (!SWIG_IsOK(res2)) {
30995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30996 }
30997 if (!argp2) {
30998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30999 }
31000 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31001 if (obj2) {
31002 ecode3 = SWIG_AsVal_int(obj2, &val3);
31003 if (!SWIG_IsOK(ecode3)) {
31004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31005 }
31006 arg3 = static_cast< wxDataObject::Direction >(val3);
31007 }
31008 {
31009 PyThreadState* __tstate = wxPyBeginAllowThreads();
31010 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31011 wxPyEndAllowThreads(__tstate);
31012 if (PyErr_Occurred()) SWIG_fail;
31013 }
31014 {
31015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31016 }
31017 return resultobj;
31018 fail:
31019 return NULL;
31020 }
31021
31022
31023 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31024 PyObject *resultobj = 0;
31025 wxDataObject *arg1 = (wxDataObject *) 0 ;
31026 wxDataFormat *arg2 = 0 ;
31027 size_t result;
31028 void *argp1 = 0 ;
31029 int res1 = 0 ;
31030 void *argp2 = 0 ;
31031 int res2 = 0 ;
31032 PyObject * obj0 = 0 ;
31033 PyObject * obj1 = 0 ;
31034 char * kwnames[] = {
31035 (char *) "self",(char *) "format", NULL
31036 };
31037
31038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31040 if (!SWIG_IsOK(res1)) {
31041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31042 }
31043 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31044 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31045 if (!SWIG_IsOK(res2)) {
31046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31047 }
31048 if (!argp2) {
31049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31050 }
31051 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31052 {
31053 PyThreadState* __tstate = wxPyBeginAllowThreads();
31054 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31055 wxPyEndAllowThreads(__tstate);
31056 if (PyErr_Occurred()) SWIG_fail;
31057 }
31058 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31059 return resultobj;
31060 fail:
31061 return NULL;
31062 }
31063
31064
31065 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31066 PyObject *resultobj = 0;
31067 wxDataObject *arg1 = (wxDataObject *) 0 ;
31068 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31069 PyObject *result = 0 ;
31070 void *argp1 = 0 ;
31071 int res1 = 0 ;
31072 int val2 ;
31073 int ecode2 = 0 ;
31074 PyObject * obj0 = 0 ;
31075 PyObject * obj1 = 0 ;
31076 char * kwnames[] = {
31077 (char *) "self",(char *) "dir", NULL
31078 };
31079
31080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31082 if (!SWIG_IsOK(res1)) {
31083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31084 }
31085 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31086 if (obj1) {
31087 ecode2 = SWIG_AsVal_int(obj1, &val2);
31088 if (!SWIG_IsOK(ecode2)) {
31089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31090 }
31091 arg2 = static_cast< wxDataObject::Direction >(val2);
31092 }
31093 {
31094 PyThreadState* __tstate = wxPyBeginAllowThreads();
31095 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 resultobj = result;
31100 return resultobj;
31101 fail:
31102 return NULL;
31103 }
31104
31105
31106 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31107 PyObject *resultobj = 0;
31108 wxDataObject *arg1 = (wxDataObject *) 0 ;
31109 wxDataFormat *arg2 = 0 ;
31110 PyObject *result = 0 ;
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 *) "format", NULL
31119 };
31120
31121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
31122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31123 if (!SWIG_IsOK(res1)) {
31124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
31125 }
31126 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31128 if (!SWIG_IsOK(res2)) {
31129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31130 }
31131 if (!argp2) {
31132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31133 }
31134 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = result;
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxDataObject *arg1 = (wxDataObject *) 0 ;
31151 wxDataFormat *arg2 = 0 ;
31152 PyObject *arg3 = (PyObject *) 0 ;
31153 bool result;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 void *argp2 = 0 ;
31157 int res2 = 0 ;
31158 PyObject * obj0 = 0 ;
31159 PyObject * obj1 = 0 ;
31160 PyObject * obj2 = 0 ;
31161 char * kwnames[] = {
31162 (char *) "self",(char *) "format",(char *) "data", NULL
31163 };
31164
31165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31167 if (!SWIG_IsOK(res1)) {
31168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
31169 }
31170 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31172 if (!SWIG_IsOK(res2)) {
31173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31174 }
31175 if (!argp2) {
31176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31177 }
31178 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31179 arg3 = obj2;
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31183 wxPyEndAllowThreads(__tstate);
31184 if (PyErr_Occurred()) SWIG_fail;
31185 }
31186 {
31187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31188 }
31189 return resultobj;
31190 fail:
31191 return NULL;
31192 }
31193
31194
31195 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31196 PyObject *obj;
31197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31198 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31199 return SWIG_Py_Void();
31200 }
31201
31202 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31203 PyObject *resultobj = 0;
31204 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31205 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31206 wxDataObjectSimple *result = 0 ;
31207 void *argp1 = 0 ;
31208 int res1 = 0 ;
31209 PyObject * obj0 = 0 ;
31210 char * kwnames[] = {
31211 (char *) "format", NULL
31212 };
31213
31214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31215 if (obj0) {
31216 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31217 if (!SWIG_IsOK(res1)) {
31218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31219 }
31220 if (!argp1) {
31221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31222 }
31223 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31224 }
31225 {
31226 PyThreadState* __tstate = wxPyBeginAllowThreads();
31227 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31228 wxPyEndAllowThreads(__tstate);
31229 if (PyErr_Occurred()) SWIG_fail;
31230 }
31231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31232 return resultobj;
31233 fail:
31234 return NULL;
31235 }
31236
31237
31238 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31239 PyObject *resultobj = 0;
31240 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31241 wxDataFormat *result = 0 ;
31242 void *argp1 = 0 ;
31243 int res1 = 0 ;
31244 PyObject *swig_obj[1] ;
31245
31246 if (!args) SWIG_fail;
31247 swig_obj[0] = args;
31248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31249 if (!SWIG_IsOK(res1)) {
31250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31251 }
31252 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31253 {
31254 PyThreadState* __tstate = wxPyBeginAllowThreads();
31255 {
31256 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31257 result = (wxDataFormat *) &_result_ref;
31258 }
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31263 return resultobj;
31264 fail:
31265 return NULL;
31266 }
31267
31268
31269 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31270 PyObject *resultobj = 0;
31271 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31272 wxDataFormat *arg2 = 0 ;
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 *) "format", NULL
31281 };
31282
31283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31285 if (!SWIG_IsOK(res1)) {
31286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31287 }
31288 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31289 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31290 if (!SWIG_IsOK(res2)) {
31291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31292 }
31293 if (!argp2) {
31294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31295 }
31296 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_Py_Void();
31304 return resultobj;
31305 fail:
31306 return NULL;
31307 }
31308
31309
31310 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31311 PyObject *resultobj = 0;
31312 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31313 size_t result;
31314 void *argp1 = 0 ;
31315 int res1 = 0 ;
31316 PyObject *swig_obj[1] ;
31317
31318 if (!args) SWIG_fail;
31319 swig_obj[0] = args;
31320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31321 if (!SWIG_IsOK(res1)) {
31322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31323 }
31324 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31325 {
31326 PyThreadState* __tstate = wxPyBeginAllowThreads();
31327 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31332 return resultobj;
31333 fail:
31334 return NULL;
31335 }
31336
31337
31338 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31339 PyObject *resultobj = 0;
31340 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31341 PyObject *result = 0 ;
31342 void *argp1 = 0 ;
31343 int res1 = 0 ;
31344 PyObject *swig_obj[1] ;
31345
31346 if (!args) SWIG_fail;
31347 swig_obj[0] = args;
31348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31349 if (!SWIG_IsOK(res1)) {
31350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31351 }
31352 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31356 wxPyEndAllowThreads(__tstate);
31357 if (PyErr_Occurred()) SWIG_fail;
31358 }
31359 resultobj = result;
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31367 PyObject *resultobj = 0;
31368 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31369 PyObject *arg2 = (PyObject *) 0 ;
31370 bool result;
31371 void *argp1 = 0 ;
31372 int res1 = 0 ;
31373 PyObject * obj0 = 0 ;
31374 PyObject * obj1 = 0 ;
31375 char * kwnames[] = {
31376 (char *) "self",(char *) "data", NULL
31377 };
31378
31379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31381 if (!SWIG_IsOK(res1)) {
31382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31383 }
31384 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31385 arg2 = obj1;
31386 {
31387 PyThreadState* __tstate = wxPyBeginAllowThreads();
31388 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 {
31393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31394 }
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31402 PyObject *obj;
31403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31404 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31405 return SWIG_Py_Void();
31406 }
31407
31408 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31409 return SWIG_Python_InitShadowInstance(args);
31410 }
31411
31412 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj = 0;
31414 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31415 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31416 wxPyDataObjectSimple *result = 0 ;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 PyObject * obj0 = 0 ;
31420 char * kwnames[] = {
31421 (char *) "format", NULL
31422 };
31423
31424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31425 if (obj0) {
31426 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31427 if (!SWIG_IsOK(res1)) {
31428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31429 }
31430 if (!argp1) {
31431 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31432 }
31433 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31434 }
31435 {
31436 PyThreadState* __tstate = wxPyBeginAllowThreads();
31437 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31442 return resultobj;
31443 fail:
31444 return NULL;
31445 }
31446
31447
31448 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31449 PyObject *resultobj = 0;
31450 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31451 PyObject *arg2 = (PyObject *) 0 ;
31452 PyObject *arg3 = (PyObject *) 0 ;
31453 void *argp1 = 0 ;
31454 int res1 = 0 ;
31455 PyObject * obj0 = 0 ;
31456 PyObject * obj1 = 0 ;
31457 PyObject * obj2 = 0 ;
31458 char * kwnames[] = {
31459 (char *) "self",(char *) "self",(char *) "_class", NULL
31460 };
31461
31462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31464 if (!SWIG_IsOK(res1)) {
31465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31466 }
31467 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31468 arg2 = obj1;
31469 arg3 = obj2;
31470 {
31471 PyThreadState* __tstate = wxPyBeginAllowThreads();
31472 (arg1)->_setCallbackInfo(arg2,arg3);
31473 wxPyEndAllowThreads(__tstate);
31474 if (PyErr_Occurred()) SWIG_fail;
31475 }
31476 resultobj = SWIG_Py_Void();
31477 return resultobj;
31478 fail:
31479 return NULL;
31480 }
31481
31482
31483 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31484 PyObject *obj;
31485 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31486 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31487 return SWIG_Py_Void();
31488 }
31489
31490 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31491 return SWIG_Python_InitShadowInstance(args);
31492 }
31493
31494 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31495 PyObject *resultobj = 0;
31496 wxDataObjectComposite *result = 0 ;
31497
31498 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31499 {
31500 PyThreadState* __tstate = wxPyBeginAllowThreads();
31501 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31513 PyObject *resultobj = 0;
31514 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31515 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31516 bool arg3 = (bool) false ;
31517 void *argp1 = 0 ;
31518 int res1 = 0 ;
31519 int res2 = 0 ;
31520 bool val3 ;
31521 int ecode3 = 0 ;
31522 PyObject * obj0 = 0 ;
31523 PyObject * obj1 = 0 ;
31524 PyObject * obj2 = 0 ;
31525 char * kwnames[] = {
31526 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31527 };
31528
31529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31531 if (!SWIG_IsOK(res1)) {
31532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31533 }
31534 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31535 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31536 if (!SWIG_IsOK(res2)) {
31537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31538 }
31539 if (obj2) {
31540 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31541 if (!SWIG_IsOK(ecode3)) {
31542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31543 }
31544 arg3 = static_cast< bool >(val3);
31545 }
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 (arg1)->Add(arg2,arg3);
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_Py_Void();
31553 return resultobj;
31554 fail:
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 PyObject *resultobj = 0;
31561 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31562 SwigValueWrapper<wxDataFormat > result;
31563 void *argp1 = 0 ;
31564 int res1 = 0 ;
31565 PyObject *swig_obj[1] ;
31566
31567 if (!args) SWIG_fail;
31568 swig_obj[0] = args;
31569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31570 if (!SWIG_IsOK(res1)) {
31571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31572 }
31573 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31588 PyObject *obj;
31589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31590 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31591 return SWIG_Py_Void();
31592 }
31593
31594 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31595 return SWIG_Python_InitShadowInstance(args);
31596 }
31597
31598 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31599 PyObject *resultobj = 0;
31600 wxString const &arg1_defvalue = wxPyEmptyString ;
31601 wxString *arg1 = (wxString *) &arg1_defvalue ;
31602 wxTextDataObject *result = 0 ;
31603 bool temp1 = false ;
31604 PyObject * obj0 = 0 ;
31605 char * kwnames[] = {
31606 (char *) "text", NULL
31607 };
31608
31609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31610 if (obj0) {
31611 {
31612 arg1 = wxString_in_helper(obj0);
31613 if (arg1 == NULL) SWIG_fail;
31614 temp1 = true;
31615 }
31616 }
31617 {
31618 PyThreadState* __tstate = wxPyBeginAllowThreads();
31619 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31620 wxPyEndAllowThreads(__tstate);
31621 if (PyErr_Occurred()) SWIG_fail;
31622 }
31623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31624 {
31625 if (temp1)
31626 delete arg1;
31627 }
31628 return resultobj;
31629 fail:
31630 {
31631 if (temp1)
31632 delete arg1;
31633 }
31634 return NULL;
31635 }
31636
31637
31638 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31639 PyObject *resultobj = 0;
31640 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31641 size_t result;
31642 void *argp1 = 0 ;
31643 int res1 = 0 ;
31644 PyObject *swig_obj[1] ;
31645
31646 if (!args) SWIG_fail;
31647 swig_obj[0] = args;
31648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31649 if (!SWIG_IsOK(res1)) {
31650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31651 }
31652 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31653 {
31654 PyThreadState* __tstate = wxPyBeginAllowThreads();
31655 result = (size_t)(arg1)->GetTextLength();
31656 wxPyEndAllowThreads(__tstate);
31657 if (PyErr_Occurred()) SWIG_fail;
31658 }
31659 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31667 PyObject *resultobj = 0;
31668 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31669 wxString result;
31670 void *argp1 = 0 ;
31671 int res1 = 0 ;
31672 PyObject *swig_obj[1] ;
31673
31674 if (!args) SWIG_fail;
31675 swig_obj[0] = args;
31676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31677 if (!SWIG_IsOK(res1)) {
31678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31679 }
31680 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 result = (arg1)->GetText();
31684 wxPyEndAllowThreads(__tstate);
31685 if (PyErr_Occurred()) SWIG_fail;
31686 }
31687 {
31688 #if wxUSE_UNICODE
31689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31690 #else
31691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31692 #endif
31693 }
31694 return resultobj;
31695 fail:
31696 return NULL;
31697 }
31698
31699
31700 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31701 PyObject *resultobj = 0;
31702 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31703 wxString *arg2 = 0 ;
31704 void *argp1 = 0 ;
31705 int res1 = 0 ;
31706 bool temp2 = false ;
31707 PyObject * obj0 = 0 ;
31708 PyObject * obj1 = 0 ;
31709 char * kwnames[] = {
31710 (char *) "self",(char *) "text", NULL
31711 };
31712
31713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31715 if (!SWIG_IsOK(res1)) {
31716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31717 }
31718 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31719 {
31720 arg2 = wxString_in_helper(obj1);
31721 if (arg2 == NULL) SWIG_fail;
31722 temp2 = true;
31723 }
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 (arg1)->SetText((wxString const &)*arg2);
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 resultobj = SWIG_Py_Void();
31731 {
31732 if (temp2)
31733 delete arg2;
31734 }
31735 return resultobj;
31736 fail:
31737 {
31738 if (temp2)
31739 delete arg2;
31740 }
31741 return NULL;
31742 }
31743
31744
31745 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31746 PyObject *obj;
31747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31748 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31749 return SWIG_Py_Void();
31750 }
31751
31752 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31753 return SWIG_Python_InitShadowInstance(args);
31754 }
31755
31756 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31757 PyObject *resultobj = 0;
31758 wxString const &arg1_defvalue = wxPyEmptyString ;
31759 wxString *arg1 = (wxString *) &arg1_defvalue ;
31760 wxPyTextDataObject *result = 0 ;
31761 bool temp1 = false ;
31762 PyObject * obj0 = 0 ;
31763 char * kwnames[] = {
31764 (char *) "text", NULL
31765 };
31766
31767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31768 if (obj0) {
31769 {
31770 arg1 = wxString_in_helper(obj0);
31771 if (arg1 == NULL) SWIG_fail;
31772 temp1 = true;
31773 }
31774 }
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31782 {
31783 if (temp1)
31784 delete arg1;
31785 }
31786 return resultobj;
31787 fail:
31788 {
31789 if (temp1)
31790 delete arg1;
31791 }
31792 return NULL;
31793 }
31794
31795
31796 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31797 PyObject *resultobj = 0;
31798 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31799 PyObject *arg2 = (PyObject *) 0 ;
31800 PyObject *arg3 = (PyObject *) 0 ;
31801 void *argp1 = 0 ;
31802 int res1 = 0 ;
31803 PyObject * obj0 = 0 ;
31804 PyObject * obj1 = 0 ;
31805 PyObject * obj2 = 0 ;
31806 char * kwnames[] = {
31807 (char *) "self",(char *) "self",(char *) "_class", NULL
31808 };
31809
31810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31812 if (!SWIG_IsOK(res1)) {
31813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31814 }
31815 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31816 arg2 = obj1;
31817 arg3 = obj2;
31818 {
31819 PyThreadState* __tstate = wxPyBeginAllowThreads();
31820 (arg1)->_setCallbackInfo(arg2,arg3);
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 resultobj = SWIG_Py_Void();
31825 return resultobj;
31826 fail:
31827 return NULL;
31828 }
31829
31830
31831 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31832 PyObject *obj;
31833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31834 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31835 return SWIG_Py_Void();
31836 }
31837
31838 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31839 return SWIG_Python_InitShadowInstance(args);
31840 }
31841
31842 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31843 PyObject *resultobj = 0;
31844 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31845 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31846 wxBitmapDataObject *result = 0 ;
31847 void *argp1 = 0 ;
31848 int res1 = 0 ;
31849 PyObject * obj0 = 0 ;
31850 char * kwnames[] = {
31851 (char *) "bitmap", NULL
31852 };
31853
31854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31855 if (obj0) {
31856 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31859 }
31860 if (!argp1) {
31861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31862 }
31863 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31864 }
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31868 wxPyEndAllowThreads(__tstate);
31869 if (PyErr_Occurred()) SWIG_fail;
31870 }
31871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31879 PyObject *resultobj = 0;
31880 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31881 wxBitmap result;
31882 void *argp1 = 0 ;
31883 int res1 = 0 ;
31884 PyObject *swig_obj[1] ;
31885
31886 if (!args) SWIG_fail;
31887 swig_obj[0] = args;
31888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31889 if (!SWIG_IsOK(res1)) {
31890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31891 }
31892 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31893 {
31894 PyThreadState* __tstate = wxPyBeginAllowThreads();
31895 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31896 wxPyEndAllowThreads(__tstate);
31897 if (PyErr_Occurred()) SWIG_fail;
31898 }
31899 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31900 return resultobj;
31901 fail:
31902 return NULL;
31903 }
31904
31905
31906 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31907 PyObject *resultobj = 0;
31908 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31909 wxBitmap *arg2 = 0 ;
31910 void *argp1 = 0 ;
31911 int res1 = 0 ;
31912 void *argp2 = 0 ;
31913 int res2 = 0 ;
31914 PyObject * obj0 = 0 ;
31915 PyObject * obj1 = 0 ;
31916 char * kwnames[] = {
31917 (char *) "self",(char *) "bitmap", NULL
31918 };
31919
31920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31922 if (!SWIG_IsOK(res1)) {
31923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31924 }
31925 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31927 if (!SWIG_IsOK(res2)) {
31928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31929 }
31930 if (!argp2) {
31931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31932 }
31933 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 resultobj = SWIG_Py_Void();
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31948 PyObject *obj;
31949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31950 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31951 return SWIG_Py_Void();
31952 }
31953
31954 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31955 return SWIG_Python_InitShadowInstance(args);
31956 }
31957
31958 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31959 PyObject *resultobj = 0;
31960 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31961 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31962 wxPyBitmapDataObject *result = 0 ;
31963 void *argp1 = 0 ;
31964 int res1 = 0 ;
31965 PyObject * obj0 = 0 ;
31966 char * kwnames[] = {
31967 (char *) "bitmap", NULL
31968 };
31969
31970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31971 if (obj0) {
31972 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31973 if (!SWIG_IsOK(res1)) {
31974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31975 }
31976 if (!argp1) {
31977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31978 }
31979 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31980 }
31981 {
31982 PyThreadState* __tstate = wxPyBeginAllowThreads();
31983 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31984 wxPyEndAllowThreads(__tstate);
31985 if (PyErr_Occurred()) SWIG_fail;
31986 }
31987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31995 PyObject *resultobj = 0;
31996 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31997 PyObject *arg2 = (PyObject *) 0 ;
31998 PyObject *arg3 = (PyObject *) 0 ;
31999 void *argp1 = 0 ;
32000 int res1 = 0 ;
32001 PyObject * obj0 = 0 ;
32002 PyObject * obj1 = 0 ;
32003 PyObject * obj2 = 0 ;
32004 char * kwnames[] = {
32005 (char *) "self",(char *) "self",(char *) "_class", NULL
32006 };
32007
32008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32010 if (!SWIG_IsOK(res1)) {
32011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32012 }
32013 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32014 arg2 = obj1;
32015 arg3 = obj2;
32016 {
32017 PyThreadState* __tstate = wxPyBeginAllowThreads();
32018 (arg1)->_setCallbackInfo(arg2,arg3);
32019 wxPyEndAllowThreads(__tstate);
32020 if (PyErr_Occurred()) SWIG_fail;
32021 }
32022 resultobj = SWIG_Py_Void();
32023 return resultobj;
32024 fail:
32025 return NULL;
32026 }
32027
32028
32029 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32030 PyObject *obj;
32031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32032 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32033 return SWIG_Py_Void();
32034 }
32035
32036 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32037 return SWIG_Python_InitShadowInstance(args);
32038 }
32039
32040 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32041 PyObject *resultobj = 0;
32042 wxFileDataObject *result = 0 ;
32043
32044 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
32045 {
32046 PyThreadState* __tstate = wxPyBeginAllowThreads();
32047 result = (wxFileDataObject *)new wxFileDataObject();
32048 wxPyEndAllowThreads(__tstate);
32049 if (PyErr_Occurred()) SWIG_fail;
32050 }
32051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32052 return resultobj;
32053 fail:
32054 return NULL;
32055 }
32056
32057
32058 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32059 PyObject *resultobj = 0;
32060 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32061 wxArrayString *result = 0 ;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 PyObject *swig_obj[1] ;
32065
32066 if (!args) SWIG_fail;
32067 swig_obj[0] = args;
32068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32069 if (!SWIG_IsOK(res1)) {
32070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32071 }
32072 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 {
32076 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32077 result = (wxArrayString *) &_result_ref;
32078 }
32079 wxPyEndAllowThreads(__tstate);
32080 if (PyErr_Occurred()) SWIG_fail;
32081 }
32082 {
32083 resultobj = wxArrayString2PyList_helper(*result);
32084 }
32085 return resultobj;
32086 fail:
32087 return NULL;
32088 }
32089
32090
32091 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32092 PyObject *resultobj = 0;
32093 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32094 wxString *arg2 = 0 ;
32095 void *argp1 = 0 ;
32096 int res1 = 0 ;
32097 bool temp2 = false ;
32098 PyObject * obj0 = 0 ;
32099 PyObject * obj1 = 0 ;
32100 char * kwnames[] = {
32101 (char *) "self",(char *) "filename", NULL
32102 };
32103
32104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
32105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32106 if (!SWIG_IsOK(res1)) {
32107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32108 }
32109 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32110 {
32111 arg2 = wxString_in_helper(obj1);
32112 if (arg2 == NULL) SWIG_fail;
32113 temp2 = true;
32114 }
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 (arg1)->AddFile((wxString const &)*arg2);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_Py_Void();
32122 {
32123 if (temp2)
32124 delete arg2;
32125 }
32126 return resultobj;
32127 fail:
32128 {
32129 if (temp2)
32130 delete arg2;
32131 }
32132 return NULL;
32133 }
32134
32135
32136 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32137 PyObject *obj;
32138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32139 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
32140 return SWIG_Py_Void();
32141 }
32142
32143 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32144 return SWIG_Python_InitShadowInstance(args);
32145 }
32146
32147 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32148 PyObject *resultobj = 0;
32149 wxDataFormat *arg1 = 0 ;
32150 wxCustomDataObject *result = 0 ;
32151 void *argp1 = 0 ;
32152 int res1 = 0 ;
32153
32154 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32156 if (!SWIG_IsOK(res1)) {
32157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32158 }
32159 if (!argp1) {
32160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32161 }
32162 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32163 {
32164 PyThreadState* __tstate = wxPyBeginAllowThreads();
32165 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32170 return resultobj;
32171 fail:
32172 return NULL;
32173 }
32174
32175
32176 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32177 PyObject *resultobj = 0;
32178 wxString *arg1 = 0 ;
32179 wxCustomDataObject *result = 0 ;
32180 bool temp1 = false ;
32181
32182 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32183 {
32184 arg1 = wxString_in_helper(swig_obj[0]);
32185 if (arg1 == NULL) SWIG_fail;
32186 temp1 = true;
32187 }
32188 {
32189 PyThreadState* __tstate = wxPyBeginAllowThreads();
32190 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32191 wxPyEndAllowThreads(__tstate);
32192 if (PyErr_Occurred()) SWIG_fail;
32193 }
32194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32195 {
32196 if (temp1)
32197 delete arg1;
32198 }
32199 return resultobj;
32200 fail:
32201 {
32202 if (temp1)
32203 delete arg1;
32204 }
32205 return NULL;
32206 }
32207
32208
32209 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32210 PyObject *resultobj = 0;
32211 wxCustomDataObject *result = 0 ;
32212
32213 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32214 {
32215 PyThreadState* __tstate = wxPyBeginAllowThreads();
32216 result = (wxCustomDataObject *)new wxCustomDataObject();
32217 wxPyEndAllowThreads(__tstate);
32218 if (PyErr_Occurred()) SWIG_fail;
32219 }
32220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32221 return resultobj;
32222 fail:
32223 return NULL;
32224 }
32225
32226
32227 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32228 int argc;
32229 PyObject *argv[2];
32230
32231 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32232 --argc;
32233 if (argc == 0) {
32234 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32235 }
32236 if (argc == 1) {
32237 int _v = 0;
32238 {
32239 {
32240 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32241 }
32242 }
32243 if (!_v) goto check_2;
32244 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32245 }
32246 check_2:
32247
32248 if (argc == 1) {
32249 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32250 }
32251
32252 fail:
32253 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32254 return NULL;
32255 }
32256
32257
32258 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj = 0;
32260 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32261 PyObject *arg2 = (PyObject *) 0 ;
32262 bool result;
32263 void *argp1 = 0 ;
32264 int res1 = 0 ;
32265 PyObject * obj0 = 0 ;
32266 PyObject * obj1 = 0 ;
32267 char * kwnames[] = {
32268 (char *) "self",(char *) "data", NULL
32269 };
32270
32271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32273 if (!SWIG_IsOK(res1)) {
32274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32275 }
32276 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32277 arg2 = obj1;
32278 {
32279 PyThreadState* __tstate = wxPyBeginAllowThreads();
32280 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32281 wxPyEndAllowThreads(__tstate);
32282 if (PyErr_Occurred()) SWIG_fail;
32283 }
32284 {
32285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32286 }
32287 return resultobj;
32288 fail:
32289 return NULL;
32290 }
32291
32292
32293 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32294 PyObject *resultobj = 0;
32295 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32296 size_t result;
32297 void *argp1 = 0 ;
32298 int res1 = 0 ;
32299 PyObject *swig_obj[1] ;
32300
32301 if (!args) SWIG_fail;
32302 swig_obj[0] = args;
32303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32304 if (!SWIG_IsOK(res1)) {
32305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32306 }
32307 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32308 {
32309 PyThreadState* __tstate = wxPyBeginAllowThreads();
32310 result = (size_t)(arg1)->GetSize();
32311 wxPyEndAllowThreads(__tstate);
32312 if (PyErr_Occurred()) SWIG_fail;
32313 }
32314 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32315 return resultobj;
32316 fail:
32317 return NULL;
32318 }
32319
32320
32321 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32322 PyObject *resultobj = 0;
32323 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32324 PyObject *result = 0 ;
32325 void *argp1 = 0 ;
32326 int res1 = 0 ;
32327 PyObject *swig_obj[1] ;
32328
32329 if (!args) SWIG_fail;
32330 swig_obj[0] = args;
32331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32332 if (!SWIG_IsOK(res1)) {
32333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32334 }
32335 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32339 wxPyEndAllowThreads(__tstate);
32340 if (PyErr_Occurred()) SWIG_fail;
32341 }
32342 resultobj = result;
32343 return resultobj;
32344 fail:
32345 return NULL;
32346 }
32347
32348
32349 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32350 PyObject *obj;
32351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32352 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32353 return SWIG_Py_Void();
32354 }
32355
32356 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32357 return SWIG_Python_InitShadowInstance(args);
32358 }
32359
32360 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32361 PyObject *resultobj = 0;
32362 wxURLDataObject *result = 0 ;
32363
32364 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32365 {
32366 PyThreadState* __tstate = wxPyBeginAllowThreads();
32367 result = (wxURLDataObject *)new wxURLDataObject();
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32379 PyObject *resultobj = 0;
32380 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32381 wxString result;
32382 void *argp1 = 0 ;
32383 int res1 = 0 ;
32384 PyObject *swig_obj[1] ;
32385
32386 if (!args) SWIG_fail;
32387 swig_obj[0] = args;
32388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32389 if (!SWIG_IsOK(res1)) {
32390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32391 }
32392 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32393 {
32394 PyThreadState* __tstate = wxPyBeginAllowThreads();
32395 result = (arg1)->GetURL();
32396 wxPyEndAllowThreads(__tstate);
32397 if (PyErr_Occurred()) SWIG_fail;
32398 }
32399 {
32400 #if wxUSE_UNICODE
32401 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32402 #else
32403 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32404 #endif
32405 }
32406 return resultobj;
32407 fail:
32408 return NULL;
32409 }
32410
32411
32412 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32413 PyObject *resultobj = 0;
32414 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32415 wxString *arg2 = 0 ;
32416 void *argp1 = 0 ;
32417 int res1 = 0 ;
32418 bool temp2 = false ;
32419 PyObject * obj0 = 0 ;
32420 PyObject * obj1 = 0 ;
32421 char * kwnames[] = {
32422 (char *) "self",(char *) "url", NULL
32423 };
32424
32425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32427 if (!SWIG_IsOK(res1)) {
32428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32429 }
32430 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32431 {
32432 arg2 = wxString_in_helper(obj1);
32433 if (arg2 == NULL) SWIG_fail;
32434 temp2 = true;
32435 }
32436 {
32437 PyThreadState* __tstate = wxPyBeginAllowThreads();
32438 (arg1)->SetURL((wxString const &)*arg2);
32439 wxPyEndAllowThreads(__tstate);
32440 if (PyErr_Occurred()) SWIG_fail;
32441 }
32442 resultobj = SWIG_Py_Void();
32443 {
32444 if (temp2)
32445 delete arg2;
32446 }
32447 return resultobj;
32448 fail:
32449 {
32450 if (temp2)
32451 delete arg2;
32452 }
32453 return NULL;
32454 }
32455
32456
32457 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32458 PyObject *obj;
32459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32460 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32461 return SWIG_Py_Void();
32462 }
32463
32464 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32465 return SWIG_Python_InitShadowInstance(args);
32466 }
32467
32468 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32469 PyObject *resultobj = 0;
32470 wxMetafileDataObject *result = 0 ;
32471
32472 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32473 {
32474 PyThreadState* __tstate = wxPyBeginAllowThreads();
32475 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32476 wxPyEndAllowThreads(__tstate);
32477 if (PyErr_Occurred()) SWIG_fail;
32478 }
32479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32480 return resultobj;
32481 fail:
32482 return NULL;
32483 }
32484
32485
32486 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32487 PyObject *resultobj = 0;
32488 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32489 wxMetafile *arg2 = 0 ;
32490 void *argp1 = 0 ;
32491 int res1 = 0 ;
32492 void *argp2 = 0 ;
32493 int res2 = 0 ;
32494 PyObject * obj0 = 0 ;
32495 PyObject * obj1 = 0 ;
32496 char * kwnames[] = {
32497 (char *) "self",(char *) "metafile", NULL
32498 };
32499
32500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32502 if (!SWIG_IsOK(res1)) {
32503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32504 }
32505 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32506 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32507 if (!SWIG_IsOK(res2)) {
32508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32509 }
32510 if (!argp2) {
32511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32512 }
32513 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32514 {
32515 PyThreadState* __tstate = wxPyBeginAllowThreads();
32516 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32517 wxPyEndAllowThreads(__tstate);
32518 if (PyErr_Occurred()) SWIG_fail;
32519 }
32520 resultobj = SWIG_Py_Void();
32521 return resultobj;
32522 fail:
32523 return NULL;
32524 }
32525
32526
32527 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32528 PyObject *resultobj = 0;
32529 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32530 wxMetafile result;
32531 void *argp1 = 0 ;
32532 int res1 = 0 ;
32533 PyObject *swig_obj[1] ;
32534
32535 if (!args) SWIG_fail;
32536 swig_obj[0] = args;
32537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32538 if (!SWIG_IsOK(res1)) {
32539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32540 }
32541 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32542 {
32543 PyThreadState* __tstate = wxPyBeginAllowThreads();
32544 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32545 wxPyEndAllowThreads(__tstate);
32546 if (PyErr_Occurred()) SWIG_fail;
32547 }
32548 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32549 return resultobj;
32550 fail:
32551 return NULL;
32552 }
32553
32554
32555 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32556 PyObject *obj;
32557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32558 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32559 return SWIG_Py_Void();
32560 }
32561
32562 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32563 return SWIG_Python_InitShadowInstance(args);
32564 }
32565
32566 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32567 PyObject *resultobj = 0;
32568 wxDragResult arg1 ;
32569 bool result;
32570 int val1 ;
32571 int ecode1 = 0 ;
32572 PyObject * obj0 = 0 ;
32573 char * kwnames[] = {
32574 (char *) "res", NULL
32575 };
32576
32577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32578 ecode1 = SWIG_AsVal_int(obj0, &val1);
32579 if (!SWIG_IsOK(ecode1)) {
32580 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32581 }
32582 arg1 = static_cast< wxDragResult >(val1);
32583 {
32584 PyThreadState* __tstate = wxPyBeginAllowThreads();
32585 result = (bool)wxIsDragResultOk(arg1);
32586 wxPyEndAllowThreads(__tstate);
32587 if (PyErr_Occurred()) SWIG_fail;
32588 }
32589 {
32590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32591 }
32592 return resultobj;
32593 fail:
32594 return NULL;
32595 }
32596
32597
32598 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32599 PyObject *resultobj = 0;
32600 wxWindow *arg1 = (wxWindow *) 0 ;
32601 wxCursor const &arg2_defvalue = wxNullCursor ;
32602 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32603 wxCursor const &arg3_defvalue = wxNullCursor ;
32604 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32605 wxCursor const &arg4_defvalue = wxNullCursor ;
32606 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32607 wxPyDropSource *result = 0 ;
32608 void *argp1 = 0 ;
32609 int res1 = 0 ;
32610 void *argp2 = 0 ;
32611 int res2 = 0 ;
32612 void *argp3 = 0 ;
32613 int res3 = 0 ;
32614 void *argp4 = 0 ;
32615 int res4 = 0 ;
32616 PyObject * obj0 = 0 ;
32617 PyObject * obj1 = 0 ;
32618 PyObject * obj2 = 0 ;
32619 PyObject * obj3 = 0 ;
32620 char * kwnames[] = {
32621 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32622 };
32623
32624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32626 if (!SWIG_IsOK(res1)) {
32627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32628 }
32629 arg1 = reinterpret_cast< wxWindow * >(argp1);
32630 if (obj1) {
32631 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32632 if (!SWIG_IsOK(res2)) {
32633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32634 }
32635 if (!argp2) {
32636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32637 }
32638 arg2 = reinterpret_cast< wxCursor * >(argp2);
32639 }
32640 if (obj2) {
32641 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32642 if (!SWIG_IsOK(res3)) {
32643 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32644 }
32645 if (!argp3) {
32646 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32647 }
32648 arg3 = reinterpret_cast< wxCursor * >(argp3);
32649 }
32650 if (obj3) {
32651 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32652 if (!SWIG_IsOK(res4)) {
32653 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32654 }
32655 if (!argp4) {
32656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32657 }
32658 arg4 = reinterpret_cast< wxCursor * >(argp4);
32659 }
32660 {
32661 PyThreadState* __tstate = wxPyBeginAllowThreads();
32662 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32663 wxPyEndAllowThreads(__tstate);
32664 if (PyErr_Occurred()) SWIG_fail;
32665 }
32666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32667 return resultobj;
32668 fail:
32669 return NULL;
32670 }
32671
32672
32673 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj = 0;
32675 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32676 PyObject *arg2 = (PyObject *) 0 ;
32677 PyObject *arg3 = (PyObject *) 0 ;
32678 int arg4 ;
32679 void *argp1 = 0 ;
32680 int res1 = 0 ;
32681 int val4 ;
32682 int ecode4 = 0 ;
32683 PyObject * obj0 = 0 ;
32684 PyObject * obj1 = 0 ;
32685 PyObject * obj2 = 0 ;
32686 PyObject * obj3 = 0 ;
32687 char * kwnames[] = {
32688 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32689 };
32690
32691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32693 if (!SWIG_IsOK(res1)) {
32694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32695 }
32696 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32697 arg2 = obj1;
32698 arg3 = obj2;
32699 ecode4 = SWIG_AsVal_int(obj3, &val4);
32700 if (!SWIG_IsOK(ecode4)) {
32701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32702 }
32703 arg4 = static_cast< int >(val4);
32704 {
32705 PyThreadState* __tstate = wxPyBeginAllowThreads();
32706 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32707 wxPyEndAllowThreads(__tstate);
32708 if (PyErr_Occurred()) SWIG_fail;
32709 }
32710 resultobj = SWIG_Py_Void();
32711 return resultobj;
32712 fail:
32713 return NULL;
32714 }
32715
32716
32717 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32718 PyObject *resultobj = 0;
32719 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32720 void *argp1 = 0 ;
32721 int res1 = 0 ;
32722 PyObject *swig_obj[1] ;
32723
32724 if (!args) SWIG_fail;
32725 swig_obj[0] = args;
32726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32727 if (!SWIG_IsOK(res1)) {
32728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32729 }
32730 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32731 {
32732 PyThreadState* __tstate = wxPyBeginAllowThreads();
32733 delete arg1;
32734
32735 wxPyEndAllowThreads(__tstate);
32736 if (PyErr_Occurred()) SWIG_fail;
32737 }
32738 resultobj = SWIG_Py_Void();
32739 return resultobj;
32740 fail:
32741 return NULL;
32742 }
32743
32744
32745 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32746 PyObject *resultobj = 0;
32747 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32748 wxDataObject *arg2 = 0 ;
32749 void *argp1 = 0 ;
32750 int res1 = 0 ;
32751 void *argp2 = 0 ;
32752 int res2 = 0 ;
32753 PyObject * obj0 = 0 ;
32754 PyObject * obj1 = 0 ;
32755 char * kwnames[] = {
32756 (char *) "self",(char *) "data", NULL
32757 };
32758
32759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32763 }
32764 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32766 if (!SWIG_IsOK(res2)) {
32767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32768 }
32769 if (!argp2) {
32770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32771 }
32772 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32773 {
32774 PyThreadState* __tstate = wxPyBeginAllowThreads();
32775 (arg1)->SetData(*arg2);
32776 wxPyEndAllowThreads(__tstate);
32777 if (PyErr_Occurred()) SWIG_fail;
32778 }
32779 resultobj = SWIG_Py_Void();
32780 return resultobj;
32781 fail:
32782 return NULL;
32783 }
32784
32785
32786 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32787 PyObject *resultobj = 0;
32788 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32789 wxDataObject *result = 0 ;
32790 void *argp1 = 0 ;
32791 int res1 = 0 ;
32792 PyObject *swig_obj[1] ;
32793
32794 if (!args) SWIG_fail;
32795 swig_obj[0] = args;
32796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32797 if (!SWIG_IsOK(res1)) {
32798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32799 }
32800 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32801 {
32802 PyThreadState* __tstate = wxPyBeginAllowThreads();
32803 result = (wxDataObject *)(arg1)->GetDataObject();
32804 wxPyEndAllowThreads(__tstate);
32805 if (PyErr_Occurred()) SWIG_fail;
32806 }
32807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32808 return resultobj;
32809 fail:
32810 return NULL;
32811 }
32812
32813
32814 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32815 PyObject *resultobj = 0;
32816 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32817 wxDragResult arg2 ;
32818 wxCursor *arg3 = 0 ;
32819 void *argp1 = 0 ;
32820 int res1 = 0 ;
32821 int val2 ;
32822 int ecode2 = 0 ;
32823 void *argp3 = 0 ;
32824 int res3 = 0 ;
32825 PyObject * obj0 = 0 ;
32826 PyObject * obj1 = 0 ;
32827 PyObject * obj2 = 0 ;
32828 char * kwnames[] = {
32829 (char *) "self",(char *) "res",(char *) "cursor", NULL
32830 };
32831
32832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32834 if (!SWIG_IsOK(res1)) {
32835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32836 }
32837 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32838 ecode2 = SWIG_AsVal_int(obj1, &val2);
32839 if (!SWIG_IsOK(ecode2)) {
32840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32841 }
32842 arg2 = static_cast< wxDragResult >(val2);
32843 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32844 if (!SWIG_IsOK(res3)) {
32845 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32846 }
32847 if (!argp3) {
32848 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32849 }
32850 arg3 = reinterpret_cast< wxCursor * >(argp3);
32851 {
32852 PyThreadState* __tstate = wxPyBeginAllowThreads();
32853 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32854 wxPyEndAllowThreads(__tstate);
32855 if (PyErr_Occurred()) SWIG_fail;
32856 }
32857 resultobj = SWIG_Py_Void();
32858 return resultobj;
32859 fail:
32860 return NULL;
32861 }
32862
32863
32864 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32865 PyObject *resultobj = 0;
32866 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32867 int arg2 = (int) wxDrag_CopyOnly ;
32868 wxDragResult result;
32869 void *argp1 = 0 ;
32870 int res1 = 0 ;
32871 int val2 ;
32872 int ecode2 = 0 ;
32873 PyObject * obj0 = 0 ;
32874 PyObject * obj1 = 0 ;
32875 char * kwnames[] = {
32876 (char *) "self",(char *) "flags", NULL
32877 };
32878
32879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32881 if (!SWIG_IsOK(res1)) {
32882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32883 }
32884 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32885 if (obj1) {
32886 ecode2 = SWIG_AsVal_int(obj1, &val2);
32887 if (!SWIG_IsOK(ecode2)) {
32888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32889 }
32890 arg2 = static_cast< int >(val2);
32891 }
32892 {
32893 PyThreadState* __tstate = wxPyBeginAllowThreads();
32894 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32895 wxPyEndAllowThreads(__tstate);
32896 if (PyErr_Occurred()) SWIG_fail;
32897 }
32898 resultobj = SWIG_From_int(static_cast< int >(result));
32899 return resultobj;
32900 fail:
32901 return NULL;
32902 }
32903
32904
32905 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32906 PyObject *resultobj = 0;
32907 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32908 wxDragResult arg2 ;
32909 bool result;
32910 void *argp1 = 0 ;
32911 int res1 = 0 ;
32912 int val2 ;
32913 int ecode2 = 0 ;
32914 PyObject * obj0 = 0 ;
32915 PyObject * obj1 = 0 ;
32916 char * kwnames[] = {
32917 (char *) "self",(char *) "effect", NULL
32918 };
32919
32920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32922 if (!SWIG_IsOK(res1)) {
32923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32924 }
32925 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32926 ecode2 = SWIG_AsVal_int(obj1, &val2);
32927 if (!SWIG_IsOK(ecode2)) {
32928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32929 }
32930 arg2 = static_cast< wxDragResult >(val2);
32931 {
32932 PyThreadState* __tstate = wxPyBeginAllowThreads();
32933 result = (bool)(arg1)->GiveFeedback(arg2);
32934 wxPyEndAllowThreads(__tstate);
32935 if (PyErr_Occurred()) SWIG_fail;
32936 }
32937 {
32938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32939 }
32940 return resultobj;
32941 fail:
32942 return NULL;
32943 }
32944
32945
32946 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32947 PyObject *obj;
32948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32949 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32950 return SWIG_Py_Void();
32951 }
32952
32953 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32954 return SWIG_Python_InitShadowInstance(args);
32955 }
32956
32957 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32958 PyObject *resultobj = 0;
32959 wxDataObject *arg1 = (wxDataObject *) NULL ;
32960 wxPyDropTarget *result = 0 ;
32961 int res1 = 0 ;
32962 PyObject * obj0 = 0 ;
32963 char * kwnames[] = {
32964 (char *) "dataObject", NULL
32965 };
32966
32967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32968 if (obj0) {
32969 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32970 if (!SWIG_IsOK(res1)) {
32971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32972 }
32973 }
32974 {
32975 PyThreadState* __tstate = wxPyBeginAllowThreads();
32976 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32977 wxPyEndAllowThreads(__tstate);
32978 if (PyErr_Occurred()) SWIG_fail;
32979 }
32980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32981 return resultobj;
32982 fail:
32983 return NULL;
32984 }
32985
32986
32987 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32988 PyObject *resultobj = 0;
32989 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32990 PyObject *arg2 = (PyObject *) 0 ;
32991 PyObject *arg3 = (PyObject *) 0 ;
32992 void *argp1 = 0 ;
32993 int res1 = 0 ;
32994 PyObject * obj0 = 0 ;
32995 PyObject * obj1 = 0 ;
32996 PyObject * obj2 = 0 ;
32997 char * kwnames[] = {
32998 (char *) "self",(char *) "self",(char *) "_class", NULL
32999 };
33000
33001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33003 if (!SWIG_IsOK(res1)) {
33004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33005 }
33006 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33007 arg2 = obj1;
33008 arg3 = obj2;
33009 {
33010 PyThreadState* __tstate = wxPyBeginAllowThreads();
33011 (arg1)->_setCallbackInfo(arg2,arg3);
33012 wxPyEndAllowThreads(__tstate);
33013 if (PyErr_Occurred()) SWIG_fail;
33014 }
33015 resultobj = SWIG_Py_Void();
33016 return resultobj;
33017 fail:
33018 return NULL;
33019 }
33020
33021
33022 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33023 PyObject *resultobj = 0;
33024 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33025 void *argp1 = 0 ;
33026 int res1 = 0 ;
33027 PyObject *swig_obj[1] ;
33028
33029 if (!args) SWIG_fail;
33030 swig_obj[0] = args;
33031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
33032 if (!SWIG_IsOK(res1)) {
33033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33034 }
33035 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33036 {
33037 PyThreadState* __tstate = wxPyBeginAllowThreads();
33038 delete arg1;
33039
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 resultobj = SWIG_Py_Void();
33044 return resultobj;
33045 fail:
33046 return NULL;
33047 }
33048
33049
33050 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33051 PyObject *resultobj = 0;
33052 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33053 wxDataObject *result = 0 ;
33054 void *argp1 = 0 ;
33055 int res1 = 0 ;
33056 PyObject *swig_obj[1] ;
33057
33058 if (!args) SWIG_fail;
33059 swig_obj[0] = args;
33060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33061 if (!SWIG_IsOK(res1)) {
33062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33063 }
33064 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = (wxDataObject *)(arg1)->GetDataObject();
33068 wxPyEndAllowThreads(__tstate);
33069 if (PyErr_Occurred()) SWIG_fail;
33070 }
33071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33072 return resultobj;
33073 fail:
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33079 PyObject *resultobj = 0;
33080 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33081 wxDataObject *arg2 = (wxDataObject *) 0 ;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 int res2 = 0 ;
33085 PyObject * obj0 = 0 ;
33086 PyObject * obj1 = 0 ;
33087 char * kwnames[] = {
33088 (char *) "self",(char *) "dataObject", NULL
33089 };
33090
33091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
33092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33093 if (!SWIG_IsOK(res1)) {
33094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33095 }
33096 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33097 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33098 if (!SWIG_IsOK(res2)) {
33099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
33100 }
33101 {
33102 PyThreadState* __tstate = wxPyBeginAllowThreads();
33103 (arg1)->SetDataObject(arg2);
33104 wxPyEndAllowThreads(__tstate);
33105 if (PyErr_Occurred()) SWIG_fail;
33106 }
33107 resultobj = SWIG_Py_Void();
33108 return resultobj;
33109 fail:
33110 return NULL;
33111 }
33112
33113
33114 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33115 PyObject *resultobj = 0;
33116 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33117 int arg2 ;
33118 int arg3 ;
33119 wxDragResult arg4 ;
33120 wxDragResult result;
33121 void *argp1 = 0 ;
33122 int res1 = 0 ;
33123 int val2 ;
33124 int ecode2 = 0 ;
33125 int val3 ;
33126 int ecode3 = 0 ;
33127 int val4 ;
33128 int ecode4 = 0 ;
33129 PyObject * obj0 = 0 ;
33130 PyObject * obj1 = 0 ;
33131 PyObject * obj2 = 0 ;
33132 PyObject * obj3 = 0 ;
33133 char * kwnames[] = {
33134 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33135 };
33136
33137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33139 if (!SWIG_IsOK(res1)) {
33140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33141 }
33142 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33143 ecode2 = SWIG_AsVal_int(obj1, &val2);
33144 if (!SWIG_IsOK(ecode2)) {
33145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33146 }
33147 arg2 = static_cast< int >(val2);
33148 ecode3 = SWIG_AsVal_int(obj2, &val3);
33149 if (!SWIG_IsOK(ecode3)) {
33150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33151 }
33152 arg3 = static_cast< int >(val3);
33153 ecode4 = SWIG_AsVal_int(obj3, &val4);
33154 if (!SWIG_IsOK(ecode4)) {
33155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33156 }
33157 arg4 = static_cast< wxDragResult >(val4);
33158 {
33159 PyThreadState* __tstate = wxPyBeginAllowThreads();
33160 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33161 wxPyEndAllowThreads(__tstate);
33162 if (PyErr_Occurred()) SWIG_fail;
33163 }
33164 resultobj = SWIG_From_int(static_cast< int >(result));
33165 return resultobj;
33166 fail:
33167 return NULL;
33168 }
33169
33170
33171 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33172 PyObject *resultobj = 0;
33173 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33174 int arg2 ;
33175 int arg3 ;
33176 wxDragResult arg4 ;
33177 wxDragResult result;
33178 void *argp1 = 0 ;
33179 int res1 = 0 ;
33180 int val2 ;
33181 int ecode2 = 0 ;
33182 int val3 ;
33183 int ecode3 = 0 ;
33184 int val4 ;
33185 int ecode4 = 0 ;
33186 PyObject * obj0 = 0 ;
33187 PyObject * obj1 = 0 ;
33188 PyObject * obj2 = 0 ;
33189 PyObject * obj3 = 0 ;
33190 char * kwnames[] = {
33191 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33192 };
33193
33194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33196 if (!SWIG_IsOK(res1)) {
33197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33198 }
33199 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33200 ecode2 = SWIG_AsVal_int(obj1, &val2);
33201 if (!SWIG_IsOK(ecode2)) {
33202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33203 }
33204 arg2 = static_cast< int >(val2);
33205 ecode3 = SWIG_AsVal_int(obj2, &val3);
33206 if (!SWIG_IsOK(ecode3)) {
33207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33208 }
33209 arg3 = static_cast< int >(val3);
33210 ecode4 = SWIG_AsVal_int(obj3, &val4);
33211 if (!SWIG_IsOK(ecode4)) {
33212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33213 }
33214 arg4 = static_cast< wxDragResult >(val4);
33215 {
33216 PyThreadState* __tstate = wxPyBeginAllowThreads();
33217 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33218 wxPyEndAllowThreads(__tstate);
33219 if (PyErr_Occurred()) SWIG_fail;
33220 }
33221 resultobj = SWIG_From_int(static_cast< int >(result));
33222 return resultobj;
33223 fail:
33224 return NULL;
33225 }
33226
33227
33228 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33229 PyObject *resultobj = 0;
33230 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33231 void *argp1 = 0 ;
33232 int res1 = 0 ;
33233 PyObject *swig_obj[1] ;
33234
33235 if (!args) SWIG_fail;
33236 swig_obj[0] = args;
33237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33238 if (!SWIG_IsOK(res1)) {
33239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33240 }
33241 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33242 {
33243 PyThreadState* __tstate = wxPyBeginAllowThreads();
33244 (arg1)->OnLeave();
33245 wxPyEndAllowThreads(__tstate);
33246 if (PyErr_Occurred()) SWIG_fail;
33247 }
33248 resultobj = SWIG_Py_Void();
33249 return resultobj;
33250 fail:
33251 return NULL;
33252 }
33253
33254
33255 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33256 PyObject *resultobj = 0;
33257 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33258 int arg2 ;
33259 int arg3 ;
33260 bool result;
33261 void *argp1 = 0 ;
33262 int res1 = 0 ;
33263 int val2 ;
33264 int ecode2 = 0 ;
33265 int val3 ;
33266 int ecode3 = 0 ;
33267 PyObject * obj0 = 0 ;
33268 PyObject * obj1 = 0 ;
33269 PyObject * obj2 = 0 ;
33270 char * kwnames[] = {
33271 (char *) "self",(char *) "x",(char *) "y", NULL
33272 };
33273
33274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33276 if (!SWIG_IsOK(res1)) {
33277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33278 }
33279 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33280 ecode2 = SWIG_AsVal_int(obj1, &val2);
33281 if (!SWIG_IsOK(ecode2)) {
33282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33283 }
33284 arg2 = static_cast< int >(val2);
33285 ecode3 = SWIG_AsVal_int(obj2, &val3);
33286 if (!SWIG_IsOK(ecode3)) {
33287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33288 }
33289 arg3 = static_cast< int >(val3);
33290 {
33291 PyThreadState* __tstate = wxPyBeginAllowThreads();
33292 result = (bool)(arg1)->OnDrop(arg2,arg3);
33293 wxPyEndAllowThreads(__tstate);
33294 if (PyErr_Occurred()) SWIG_fail;
33295 }
33296 {
33297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33298 }
33299 return resultobj;
33300 fail:
33301 return NULL;
33302 }
33303
33304
33305 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33306 PyObject *resultobj = 0;
33307 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33308 bool result;
33309 void *argp1 = 0 ;
33310 int res1 = 0 ;
33311 PyObject *swig_obj[1] ;
33312
33313 if (!args) SWIG_fail;
33314 swig_obj[0] = args;
33315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33316 if (!SWIG_IsOK(res1)) {
33317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33318 }
33319 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33320 {
33321 PyThreadState* __tstate = wxPyBeginAllowThreads();
33322 result = (bool)(arg1)->GetData();
33323 wxPyEndAllowThreads(__tstate);
33324 if (PyErr_Occurred()) SWIG_fail;
33325 }
33326 {
33327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33328 }
33329 return resultobj;
33330 fail:
33331 return NULL;
33332 }
33333
33334
33335 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33336 PyObject *resultobj = 0;
33337 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33338 wxDragResult arg2 ;
33339 void *argp1 = 0 ;
33340 int res1 = 0 ;
33341 int val2 ;
33342 int ecode2 = 0 ;
33343 PyObject * obj0 = 0 ;
33344 PyObject * obj1 = 0 ;
33345 char * kwnames[] = {
33346 (char *) "self",(char *) "action", NULL
33347 };
33348
33349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33351 if (!SWIG_IsOK(res1)) {
33352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33353 }
33354 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33355 ecode2 = SWIG_AsVal_int(obj1, &val2);
33356 if (!SWIG_IsOK(ecode2)) {
33357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33358 }
33359 arg2 = static_cast< wxDragResult >(val2);
33360 {
33361 PyThreadState* __tstate = wxPyBeginAllowThreads();
33362 (arg1)->SetDefaultAction(arg2);
33363 wxPyEndAllowThreads(__tstate);
33364 if (PyErr_Occurred()) SWIG_fail;
33365 }
33366 resultobj = SWIG_Py_Void();
33367 return resultobj;
33368 fail:
33369 return NULL;
33370 }
33371
33372
33373 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33374 PyObject *resultobj = 0;
33375 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33376 wxDragResult result;
33377 void *argp1 = 0 ;
33378 int res1 = 0 ;
33379 PyObject *swig_obj[1] ;
33380
33381 if (!args) SWIG_fail;
33382 swig_obj[0] = args;
33383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33384 if (!SWIG_IsOK(res1)) {
33385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33386 }
33387 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 result = (wxDragResult)(arg1)->GetDefaultAction();
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 resultobj = SWIG_From_int(static_cast< int >(result));
33395 return resultobj;
33396 fail:
33397 return NULL;
33398 }
33399
33400
33401 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33402 PyObject *obj;
33403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33404 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33405 return SWIG_Py_Void();
33406 }
33407
33408 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33409 return SWIG_Python_InitShadowInstance(args);
33410 }
33411
33412 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33413 PyObject *resultobj = 0;
33414 wxPyTextDropTarget *result = 0 ;
33415
33416 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33417 {
33418 PyThreadState* __tstate = wxPyBeginAllowThreads();
33419 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33420 wxPyEndAllowThreads(__tstate);
33421 if (PyErr_Occurred()) SWIG_fail;
33422 }
33423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33424 return resultobj;
33425 fail:
33426 return NULL;
33427 }
33428
33429
33430 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33431 PyObject *resultobj = 0;
33432 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33433 PyObject *arg2 = (PyObject *) 0 ;
33434 PyObject *arg3 = (PyObject *) 0 ;
33435 void *argp1 = 0 ;
33436 int res1 = 0 ;
33437 PyObject * obj0 = 0 ;
33438 PyObject * obj1 = 0 ;
33439 PyObject * obj2 = 0 ;
33440 char * kwnames[] = {
33441 (char *) "self",(char *) "self",(char *) "_class", NULL
33442 };
33443
33444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33446 if (!SWIG_IsOK(res1)) {
33447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33448 }
33449 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33450 arg2 = obj1;
33451 arg3 = obj2;
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 (arg1)->_setCallbackInfo(arg2,arg3);
33455 wxPyEndAllowThreads(__tstate);
33456 if (PyErr_Occurred()) SWIG_fail;
33457 }
33458 resultobj = SWIG_Py_Void();
33459 return resultobj;
33460 fail:
33461 return NULL;
33462 }
33463
33464
33465 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33466 PyObject *resultobj = 0;
33467 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33468 int arg2 ;
33469 int arg3 ;
33470 wxString *arg4 = 0 ;
33471 bool result;
33472 void *argp1 = 0 ;
33473 int res1 = 0 ;
33474 int val2 ;
33475 int ecode2 = 0 ;
33476 int val3 ;
33477 int ecode3 = 0 ;
33478 bool temp4 = false ;
33479 PyObject * obj0 = 0 ;
33480 PyObject * obj1 = 0 ;
33481 PyObject * obj2 = 0 ;
33482 PyObject * obj3 = 0 ;
33483 char * kwnames[] = {
33484 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33485 };
33486
33487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33489 if (!SWIG_IsOK(res1)) {
33490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33491 }
33492 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33493 ecode2 = SWIG_AsVal_int(obj1, &val2);
33494 if (!SWIG_IsOK(ecode2)) {
33495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33496 }
33497 arg2 = static_cast< int >(val2);
33498 ecode3 = SWIG_AsVal_int(obj2, &val3);
33499 if (!SWIG_IsOK(ecode3)) {
33500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33501 }
33502 arg3 = static_cast< int >(val3);
33503 {
33504 arg4 = wxString_in_helper(obj3);
33505 if (arg4 == NULL) SWIG_fail;
33506 temp4 = true;
33507 }
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 {
33515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33516 }
33517 {
33518 if (temp4)
33519 delete arg4;
33520 }
33521 return resultobj;
33522 fail:
33523 {
33524 if (temp4)
33525 delete arg4;
33526 }
33527 return NULL;
33528 }
33529
33530
33531 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33532 PyObject *resultobj = 0;
33533 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33534 int arg2 ;
33535 int arg3 ;
33536 wxDragResult arg4 ;
33537 wxDragResult result;
33538 void *argp1 = 0 ;
33539 int res1 = 0 ;
33540 int val2 ;
33541 int ecode2 = 0 ;
33542 int val3 ;
33543 int ecode3 = 0 ;
33544 int val4 ;
33545 int ecode4 = 0 ;
33546 PyObject * obj0 = 0 ;
33547 PyObject * obj1 = 0 ;
33548 PyObject * obj2 = 0 ;
33549 PyObject * obj3 = 0 ;
33550 char * kwnames[] = {
33551 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33552 };
33553
33554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33556 if (!SWIG_IsOK(res1)) {
33557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33558 }
33559 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33560 ecode2 = SWIG_AsVal_int(obj1, &val2);
33561 if (!SWIG_IsOK(ecode2)) {
33562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33563 }
33564 arg2 = static_cast< int >(val2);
33565 ecode3 = SWIG_AsVal_int(obj2, &val3);
33566 if (!SWIG_IsOK(ecode3)) {
33567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33568 }
33569 arg3 = static_cast< int >(val3);
33570 ecode4 = SWIG_AsVal_int(obj3, &val4);
33571 if (!SWIG_IsOK(ecode4)) {
33572 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33573 }
33574 arg4 = static_cast< wxDragResult >(val4);
33575 {
33576 PyThreadState* __tstate = wxPyBeginAllowThreads();
33577 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33578 wxPyEndAllowThreads(__tstate);
33579 if (PyErr_Occurred()) SWIG_fail;
33580 }
33581 resultobj = SWIG_From_int(static_cast< int >(result));
33582 return resultobj;
33583 fail:
33584 return NULL;
33585 }
33586
33587
33588 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33589 PyObject *resultobj = 0;
33590 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33591 int arg2 ;
33592 int arg3 ;
33593 wxDragResult arg4 ;
33594 wxDragResult result;
33595 void *argp1 = 0 ;
33596 int res1 = 0 ;
33597 int val2 ;
33598 int ecode2 = 0 ;
33599 int val3 ;
33600 int ecode3 = 0 ;
33601 int val4 ;
33602 int ecode4 = 0 ;
33603 PyObject * obj0 = 0 ;
33604 PyObject * obj1 = 0 ;
33605 PyObject * obj2 = 0 ;
33606 PyObject * obj3 = 0 ;
33607 char * kwnames[] = {
33608 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33609 };
33610
33611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33613 if (!SWIG_IsOK(res1)) {
33614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33615 }
33616 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33617 ecode2 = SWIG_AsVal_int(obj1, &val2);
33618 if (!SWIG_IsOK(ecode2)) {
33619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33620 }
33621 arg2 = static_cast< int >(val2);
33622 ecode3 = SWIG_AsVal_int(obj2, &val3);
33623 if (!SWIG_IsOK(ecode3)) {
33624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33625 }
33626 arg3 = static_cast< int >(val3);
33627 ecode4 = SWIG_AsVal_int(obj3, &val4);
33628 if (!SWIG_IsOK(ecode4)) {
33629 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33630 }
33631 arg4 = static_cast< wxDragResult >(val4);
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 resultobj = SWIG_From_int(static_cast< int >(result));
33639 return resultobj;
33640 fail:
33641 return NULL;
33642 }
33643
33644
33645 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33646 PyObject *resultobj = 0;
33647 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33648 void *argp1 = 0 ;
33649 int res1 = 0 ;
33650 PyObject *swig_obj[1] ;
33651
33652 if (!args) SWIG_fail;
33653 swig_obj[0] = args;
33654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33655 if (!SWIG_IsOK(res1)) {
33656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33657 }
33658 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 (arg1)->OnLeave();
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 resultobj = SWIG_Py_Void();
33666 return resultobj;
33667 fail:
33668 return NULL;
33669 }
33670
33671
33672 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33673 PyObject *resultobj = 0;
33674 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33675 int arg2 ;
33676 int arg3 ;
33677 bool result;
33678 void *argp1 = 0 ;
33679 int res1 = 0 ;
33680 int val2 ;
33681 int ecode2 = 0 ;
33682 int val3 ;
33683 int ecode3 = 0 ;
33684 PyObject * obj0 = 0 ;
33685 PyObject * obj1 = 0 ;
33686 PyObject * obj2 = 0 ;
33687 char * kwnames[] = {
33688 (char *) "self",(char *) "x",(char *) "y", NULL
33689 };
33690
33691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33693 if (!SWIG_IsOK(res1)) {
33694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33695 }
33696 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33697 ecode2 = SWIG_AsVal_int(obj1, &val2);
33698 if (!SWIG_IsOK(ecode2)) {
33699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33700 }
33701 arg2 = static_cast< int >(val2);
33702 ecode3 = SWIG_AsVal_int(obj2, &val3);
33703 if (!SWIG_IsOK(ecode3)) {
33704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33705 }
33706 arg3 = static_cast< int >(val3);
33707 {
33708 PyThreadState* __tstate = wxPyBeginAllowThreads();
33709 result = (bool)(arg1)->OnDrop(arg2,arg3);
33710 wxPyEndAllowThreads(__tstate);
33711 if (PyErr_Occurred()) SWIG_fail;
33712 }
33713 {
33714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33715 }
33716 return resultobj;
33717 fail:
33718 return NULL;
33719 }
33720
33721
33722 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33723 PyObject *resultobj = 0;
33724 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33725 int arg2 ;
33726 int arg3 ;
33727 wxDragResult arg4 ;
33728 wxDragResult result;
33729 void *argp1 = 0 ;
33730 int res1 = 0 ;
33731 int val2 ;
33732 int ecode2 = 0 ;
33733 int val3 ;
33734 int ecode3 = 0 ;
33735 int val4 ;
33736 int ecode4 = 0 ;
33737 PyObject * obj0 = 0 ;
33738 PyObject * obj1 = 0 ;
33739 PyObject * obj2 = 0 ;
33740 PyObject * obj3 = 0 ;
33741 char * kwnames[] = {
33742 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33743 };
33744
33745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33747 if (!SWIG_IsOK(res1)) {
33748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33749 }
33750 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33751 ecode2 = SWIG_AsVal_int(obj1, &val2);
33752 if (!SWIG_IsOK(ecode2)) {
33753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33754 }
33755 arg2 = static_cast< int >(val2);
33756 ecode3 = SWIG_AsVal_int(obj2, &val3);
33757 if (!SWIG_IsOK(ecode3)) {
33758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33759 }
33760 arg3 = static_cast< int >(val3);
33761 ecode4 = SWIG_AsVal_int(obj3, &val4);
33762 if (!SWIG_IsOK(ecode4)) {
33763 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33764 }
33765 arg4 = static_cast< wxDragResult >(val4);
33766 {
33767 PyThreadState* __tstate = wxPyBeginAllowThreads();
33768 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 resultobj = SWIG_From_int(static_cast< int >(result));
33773 return resultobj;
33774 fail:
33775 return NULL;
33776 }
33777
33778
33779 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33780 PyObject *obj;
33781 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33782 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33783 return SWIG_Py_Void();
33784 }
33785
33786 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33787 return SWIG_Python_InitShadowInstance(args);
33788 }
33789
33790 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33791 PyObject *resultobj = 0;
33792 wxPyFileDropTarget *result = 0 ;
33793
33794 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33795 {
33796 PyThreadState* __tstate = wxPyBeginAllowThreads();
33797 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33798 wxPyEndAllowThreads(__tstate);
33799 if (PyErr_Occurred()) SWIG_fail;
33800 }
33801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33802 return resultobj;
33803 fail:
33804 return NULL;
33805 }
33806
33807
33808 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33809 PyObject *resultobj = 0;
33810 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33811 PyObject *arg2 = (PyObject *) 0 ;
33812 PyObject *arg3 = (PyObject *) 0 ;
33813 void *argp1 = 0 ;
33814 int res1 = 0 ;
33815 PyObject * obj0 = 0 ;
33816 PyObject * obj1 = 0 ;
33817 PyObject * obj2 = 0 ;
33818 char * kwnames[] = {
33819 (char *) "self",(char *) "self",(char *) "_class", NULL
33820 };
33821
33822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33824 if (!SWIG_IsOK(res1)) {
33825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33826 }
33827 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33828 arg2 = obj1;
33829 arg3 = obj2;
33830 {
33831 PyThreadState* __tstate = wxPyBeginAllowThreads();
33832 (arg1)->_setCallbackInfo(arg2,arg3);
33833 wxPyEndAllowThreads(__tstate);
33834 if (PyErr_Occurred()) SWIG_fail;
33835 }
33836 resultobj = SWIG_Py_Void();
33837 return resultobj;
33838 fail:
33839 return NULL;
33840 }
33841
33842
33843 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33844 PyObject *resultobj = 0;
33845 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33846 int arg2 ;
33847 int arg3 ;
33848 wxArrayString *arg4 = 0 ;
33849 bool result;
33850 void *argp1 = 0 ;
33851 int res1 = 0 ;
33852 int val2 ;
33853 int ecode2 = 0 ;
33854 int val3 ;
33855 int ecode3 = 0 ;
33856 bool temp4 = false ;
33857 PyObject * obj0 = 0 ;
33858 PyObject * obj1 = 0 ;
33859 PyObject * obj2 = 0 ;
33860 PyObject * obj3 = 0 ;
33861 char * kwnames[] = {
33862 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33863 };
33864
33865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33867 if (!SWIG_IsOK(res1)) {
33868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33869 }
33870 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33871 ecode2 = SWIG_AsVal_int(obj1, &val2);
33872 if (!SWIG_IsOK(ecode2)) {
33873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33874 }
33875 arg2 = static_cast< int >(val2);
33876 ecode3 = SWIG_AsVal_int(obj2, &val3);
33877 if (!SWIG_IsOK(ecode3)) {
33878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33879 }
33880 arg3 = static_cast< int >(val3);
33881 {
33882 if (! PySequence_Check(obj3)) {
33883 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33884 SWIG_fail;
33885 }
33886 arg4 = new wxArrayString;
33887 temp4 = true;
33888 int i, len=PySequence_Length(obj3);
33889 for (i=0; i<len; i++) {
33890 PyObject* item = PySequence_GetItem(obj3, i);
33891 wxString* s = wxString_in_helper(item);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 arg4->Add(*s);
33894 delete s;
33895 Py_DECREF(item);
33896 }
33897 }
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33906 }
33907 {
33908 if (temp4) delete arg4;
33909 }
33910 return resultobj;
33911 fail:
33912 {
33913 if (temp4) delete arg4;
33914 }
33915 return NULL;
33916 }
33917
33918
33919 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33920 PyObject *resultobj = 0;
33921 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33922 int arg2 ;
33923 int arg3 ;
33924 wxDragResult arg4 ;
33925 wxDragResult result;
33926 void *argp1 = 0 ;
33927 int res1 = 0 ;
33928 int val2 ;
33929 int ecode2 = 0 ;
33930 int val3 ;
33931 int ecode3 = 0 ;
33932 int val4 ;
33933 int ecode4 = 0 ;
33934 PyObject * obj0 = 0 ;
33935 PyObject * obj1 = 0 ;
33936 PyObject * obj2 = 0 ;
33937 PyObject * obj3 = 0 ;
33938 char * kwnames[] = {
33939 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33940 };
33941
33942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33944 if (!SWIG_IsOK(res1)) {
33945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33946 }
33947 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33948 ecode2 = SWIG_AsVal_int(obj1, &val2);
33949 if (!SWIG_IsOK(ecode2)) {
33950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33951 }
33952 arg2 = static_cast< int >(val2);
33953 ecode3 = SWIG_AsVal_int(obj2, &val3);
33954 if (!SWIG_IsOK(ecode3)) {
33955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33956 }
33957 arg3 = static_cast< int >(val3);
33958 ecode4 = SWIG_AsVal_int(obj3, &val4);
33959 if (!SWIG_IsOK(ecode4)) {
33960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33961 }
33962 arg4 = static_cast< wxDragResult >(val4);
33963 {
33964 PyThreadState* __tstate = wxPyBeginAllowThreads();
33965 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33966 wxPyEndAllowThreads(__tstate);
33967 if (PyErr_Occurred()) SWIG_fail;
33968 }
33969 resultobj = SWIG_From_int(static_cast< int >(result));
33970 return resultobj;
33971 fail:
33972 return NULL;
33973 }
33974
33975
33976 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33977 PyObject *resultobj = 0;
33978 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33979 int arg2 ;
33980 int arg3 ;
33981 wxDragResult arg4 ;
33982 wxDragResult result;
33983 void *argp1 = 0 ;
33984 int res1 = 0 ;
33985 int val2 ;
33986 int ecode2 = 0 ;
33987 int val3 ;
33988 int ecode3 = 0 ;
33989 int val4 ;
33990 int ecode4 = 0 ;
33991 PyObject * obj0 = 0 ;
33992 PyObject * obj1 = 0 ;
33993 PyObject * obj2 = 0 ;
33994 PyObject * obj3 = 0 ;
33995 char * kwnames[] = {
33996 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33997 };
33998
33999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34001 if (!SWIG_IsOK(res1)) {
34002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34003 }
34004 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34005 ecode2 = SWIG_AsVal_int(obj1, &val2);
34006 if (!SWIG_IsOK(ecode2)) {
34007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34008 }
34009 arg2 = static_cast< int >(val2);
34010 ecode3 = SWIG_AsVal_int(obj2, &val3);
34011 if (!SWIG_IsOK(ecode3)) {
34012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34013 }
34014 arg3 = static_cast< int >(val3);
34015 ecode4 = SWIG_AsVal_int(obj3, &val4);
34016 if (!SWIG_IsOK(ecode4)) {
34017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34018 }
34019 arg4 = static_cast< wxDragResult >(val4);
34020 {
34021 PyThreadState* __tstate = wxPyBeginAllowThreads();
34022 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34023 wxPyEndAllowThreads(__tstate);
34024 if (PyErr_Occurred()) SWIG_fail;
34025 }
34026 resultobj = SWIG_From_int(static_cast< int >(result));
34027 return resultobj;
34028 fail:
34029 return NULL;
34030 }
34031
34032
34033 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34034 PyObject *resultobj = 0;
34035 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34036 void *argp1 = 0 ;
34037 int res1 = 0 ;
34038 PyObject *swig_obj[1] ;
34039
34040 if (!args) SWIG_fail;
34041 swig_obj[0] = args;
34042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34043 if (!SWIG_IsOK(res1)) {
34044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34045 }
34046 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34047 {
34048 PyThreadState* __tstate = wxPyBeginAllowThreads();
34049 (arg1)->OnLeave();
34050 wxPyEndAllowThreads(__tstate);
34051 if (PyErr_Occurred()) SWIG_fail;
34052 }
34053 resultobj = SWIG_Py_Void();
34054 return resultobj;
34055 fail:
34056 return NULL;
34057 }
34058
34059
34060 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34061 PyObject *resultobj = 0;
34062 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34063 int arg2 ;
34064 int arg3 ;
34065 bool result;
34066 void *argp1 = 0 ;
34067 int res1 = 0 ;
34068 int val2 ;
34069 int ecode2 = 0 ;
34070 int val3 ;
34071 int ecode3 = 0 ;
34072 PyObject * obj0 = 0 ;
34073 PyObject * obj1 = 0 ;
34074 PyObject * obj2 = 0 ;
34075 char * kwnames[] = {
34076 (char *) "self",(char *) "x",(char *) "y", NULL
34077 };
34078
34079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34083 }
34084 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34085 ecode2 = SWIG_AsVal_int(obj1, &val2);
34086 if (!SWIG_IsOK(ecode2)) {
34087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34088 }
34089 arg2 = static_cast< int >(val2);
34090 ecode3 = SWIG_AsVal_int(obj2, &val3);
34091 if (!SWIG_IsOK(ecode3)) {
34092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34093 }
34094 arg3 = static_cast< int >(val3);
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
34097 result = (bool)(arg1)->OnDrop(arg2,arg3);
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 {
34102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34103 }
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34111 PyObject *resultobj = 0;
34112 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34113 int arg2 ;
34114 int arg3 ;
34115 wxDragResult arg4 ;
34116 wxDragResult result;
34117 void *argp1 = 0 ;
34118 int res1 = 0 ;
34119 int val2 ;
34120 int ecode2 = 0 ;
34121 int val3 ;
34122 int ecode3 = 0 ;
34123 int val4 ;
34124 int ecode4 = 0 ;
34125 PyObject * obj0 = 0 ;
34126 PyObject * obj1 = 0 ;
34127 PyObject * obj2 = 0 ;
34128 PyObject * obj3 = 0 ;
34129 char * kwnames[] = {
34130 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34131 };
34132
34133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34135 if (!SWIG_IsOK(res1)) {
34136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34137 }
34138 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34139 ecode2 = SWIG_AsVal_int(obj1, &val2);
34140 if (!SWIG_IsOK(ecode2)) {
34141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34142 }
34143 arg2 = static_cast< int >(val2);
34144 ecode3 = SWIG_AsVal_int(obj2, &val3);
34145 if (!SWIG_IsOK(ecode3)) {
34146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34147 }
34148 arg3 = static_cast< int >(val3);
34149 ecode4 = SWIG_AsVal_int(obj3, &val4);
34150 if (!SWIG_IsOK(ecode4)) {
34151 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34152 }
34153 arg4 = static_cast< wxDragResult >(val4);
34154 {
34155 PyThreadState* __tstate = wxPyBeginAllowThreads();
34156 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34157 wxPyEndAllowThreads(__tstate);
34158 if (PyErr_Occurred()) SWIG_fail;
34159 }
34160 resultobj = SWIG_From_int(static_cast< int >(result));
34161 return resultobj;
34162 fail:
34163 return NULL;
34164 }
34165
34166
34167 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34168 PyObject *obj;
34169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34170 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
34171 return SWIG_Py_Void();
34172 }
34173
34174 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34175 return SWIG_Python_InitShadowInstance(args);
34176 }
34177
34178 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34179 PyObject *resultobj = 0;
34180 wxClipboard *result = 0 ;
34181
34182 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34183 {
34184 PyThreadState* __tstate = wxPyBeginAllowThreads();
34185 result = (wxClipboard *)new wxClipboard();
34186 wxPyEndAllowThreads(__tstate);
34187 if (PyErr_Occurred()) SWIG_fail;
34188 }
34189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34190 return resultobj;
34191 fail:
34192 return NULL;
34193 }
34194
34195
34196 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34197 PyObject *resultobj = 0;
34198 wxClipboard *arg1 = (wxClipboard *) 0 ;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 PyObject *swig_obj[1] ;
34202
34203 if (!args) SWIG_fail;
34204 swig_obj[0] = args;
34205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34206 if (!SWIG_IsOK(res1)) {
34207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34208 }
34209 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 delete arg1;
34213
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 resultobj = SWIG_Py_Void();
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34225 PyObject *resultobj = 0;
34226 wxClipboard *arg1 = (wxClipboard *) 0 ;
34227 bool result;
34228 void *argp1 = 0 ;
34229 int res1 = 0 ;
34230 PyObject *swig_obj[1] ;
34231
34232 if (!args) SWIG_fail;
34233 swig_obj[0] = args;
34234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34235 if (!SWIG_IsOK(res1)) {
34236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34237 }
34238 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34239 {
34240 PyThreadState* __tstate = wxPyBeginAllowThreads();
34241 result = (bool)(arg1)->Open();
34242 wxPyEndAllowThreads(__tstate);
34243 if (PyErr_Occurred()) SWIG_fail;
34244 }
34245 {
34246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34247 }
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34255 PyObject *resultobj = 0;
34256 wxClipboard *arg1 = (wxClipboard *) 0 ;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 PyObject *swig_obj[1] ;
34260
34261 if (!args) SWIG_fail;
34262 swig_obj[0] = args;
34263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34264 if (!SWIG_IsOK(res1)) {
34265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34266 }
34267 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34268 {
34269 PyThreadState* __tstate = wxPyBeginAllowThreads();
34270 (arg1)->Close();
34271 wxPyEndAllowThreads(__tstate);
34272 if (PyErr_Occurred()) SWIG_fail;
34273 }
34274 resultobj = SWIG_Py_Void();
34275 return resultobj;
34276 fail:
34277 return NULL;
34278 }
34279
34280
34281 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34282 PyObject *resultobj = 0;
34283 wxClipboard *arg1 = (wxClipboard *) 0 ;
34284 bool result;
34285 void *argp1 = 0 ;
34286 int res1 = 0 ;
34287 PyObject *swig_obj[1] ;
34288
34289 if (!args) SWIG_fail;
34290 swig_obj[0] = args;
34291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34292 if (!SWIG_IsOK(res1)) {
34293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34294 }
34295 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34296 {
34297 PyThreadState* __tstate = wxPyBeginAllowThreads();
34298 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34299 wxPyEndAllowThreads(__tstate);
34300 if (PyErr_Occurred()) SWIG_fail;
34301 }
34302 {
34303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34304 }
34305 return resultobj;
34306 fail:
34307 return NULL;
34308 }
34309
34310
34311 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34312 PyObject *resultobj = 0;
34313 wxClipboard *arg1 = (wxClipboard *) 0 ;
34314 wxDataObject *arg2 = (wxDataObject *) 0 ;
34315 bool result;
34316 void *argp1 = 0 ;
34317 int res1 = 0 ;
34318 int res2 = 0 ;
34319 PyObject * obj0 = 0 ;
34320 PyObject * obj1 = 0 ;
34321 char * kwnames[] = {
34322 (char *) "self",(char *) "data", NULL
34323 };
34324
34325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34329 }
34330 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34331 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34332 if (!SWIG_IsOK(res2)) {
34333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34334 }
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 result = (bool)(arg1)->AddData(arg2);
34338 wxPyEndAllowThreads(__tstate);
34339 if (PyErr_Occurred()) SWIG_fail;
34340 }
34341 {
34342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34343 }
34344 return resultobj;
34345 fail:
34346 return NULL;
34347 }
34348
34349
34350 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34351 PyObject *resultobj = 0;
34352 wxClipboard *arg1 = (wxClipboard *) 0 ;
34353 wxDataObject *arg2 = (wxDataObject *) 0 ;
34354 bool result;
34355 void *argp1 = 0 ;
34356 int res1 = 0 ;
34357 int res2 = 0 ;
34358 PyObject * obj0 = 0 ;
34359 PyObject * obj1 = 0 ;
34360 char * kwnames[] = {
34361 (char *) "self",(char *) "data", NULL
34362 };
34363
34364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34366 if (!SWIG_IsOK(res1)) {
34367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34368 }
34369 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34370 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34371 if (!SWIG_IsOK(res2)) {
34372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34373 }
34374 {
34375 PyThreadState* __tstate = wxPyBeginAllowThreads();
34376 result = (bool)(arg1)->SetData(arg2);
34377 wxPyEndAllowThreads(__tstate);
34378 if (PyErr_Occurred()) SWIG_fail;
34379 }
34380 {
34381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34382 }
34383 return resultobj;
34384 fail:
34385 return NULL;
34386 }
34387
34388
34389 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34390 PyObject *resultobj = 0;
34391 wxClipboard *arg1 = (wxClipboard *) 0 ;
34392 wxDataFormat *arg2 = 0 ;
34393 bool result;
34394 void *argp1 = 0 ;
34395 int res1 = 0 ;
34396 void *argp2 = 0 ;
34397 int res2 = 0 ;
34398 PyObject * obj0 = 0 ;
34399 PyObject * obj1 = 0 ;
34400 char * kwnames[] = {
34401 (char *) "self",(char *) "format", NULL
34402 };
34403
34404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34406 if (!SWIG_IsOK(res1)) {
34407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34408 }
34409 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34410 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34411 if (!SWIG_IsOK(res2)) {
34412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34413 }
34414 if (!argp2) {
34415 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34416 }
34417 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 {
34425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34426 }
34427 return resultobj;
34428 fail:
34429 return NULL;
34430 }
34431
34432
34433 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34434 PyObject *resultobj = 0;
34435 wxClipboard *arg1 = (wxClipboard *) 0 ;
34436 wxDataObject *arg2 = 0 ;
34437 bool result;
34438 void *argp1 = 0 ;
34439 int res1 = 0 ;
34440 void *argp2 = 0 ;
34441 int res2 = 0 ;
34442 PyObject * obj0 = 0 ;
34443 PyObject * obj1 = 0 ;
34444 char * kwnames[] = {
34445 (char *) "self",(char *) "data", NULL
34446 };
34447
34448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34450 if (!SWIG_IsOK(res1)) {
34451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34452 }
34453 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34455 if (!SWIG_IsOK(res2)) {
34456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34457 }
34458 if (!argp2) {
34459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34460 }
34461 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 result = (bool)(arg1)->GetData(*arg2);
34465 wxPyEndAllowThreads(__tstate);
34466 if (PyErr_Occurred()) SWIG_fail;
34467 }
34468 {
34469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34470 }
34471 return resultobj;
34472 fail:
34473 return NULL;
34474 }
34475
34476
34477 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34478 PyObject *resultobj = 0;
34479 wxClipboard *arg1 = (wxClipboard *) 0 ;
34480 void *argp1 = 0 ;
34481 int res1 = 0 ;
34482 PyObject *swig_obj[1] ;
34483
34484 if (!args) SWIG_fail;
34485 swig_obj[0] = args;
34486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34487 if (!SWIG_IsOK(res1)) {
34488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34489 }
34490 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34491 {
34492 PyThreadState* __tstate = wxPyBeginAllowThreads();
34493 (arg1)->Clear();
34494 wxPyEndAllowThreads(__tstate);
34495 if (PyErr_Occurred()) SWIG_fail;
34496 }
34497 resultobj = SWIG_Py_Void();
34498 return resultobj;
34499 fail:
34500 return NULL;
34501 }
34502
34503
34504 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34505 PyObject *resultobj = 0;
34506 wxClipboard *arg1 = (wxClipboard *) 0 ;
34507 bool result;
34508 void *argp1 = 0 ;
34509 int res1 = 0 ;
34510 PyObject *swig_obj[1] ;
34511
34512 if (!args) SWIG_fail;
34513 swig_obj[0] = args;
34514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34515 if (!SWIG_IsOK(res1)) {
34516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34517 }
34518 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34519 {
34520 PyThreadState* __tstate = wxPyBeginAllowThreads();
34521 result = (bool)(arg1)->Flush();
34522 wxPyEndAllowThreads(__tstate);
34523 if (PyErr_Occurred()) SWIG_fail;
34524 }
34525 {
34526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34527 }
34528 return resultobj;
34529 fail:
34530 return NULL;
34531 }
34532
34533
34534 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34535 PyObject *resultobj = 0;
34536 wxClipboard *arg1 = (wxClipboard *) 0 ;
34537 bool arg2 = (bool) true ;
34538 void *argp1 = 0 ;
34539 int res1 = 0 ;
34540 bool val2 ;
34541 int ecode2 = 0 ;
34542 PyObject * obj0 = 0 ;
34543 PyObject * obj1 = 0 ;
34544 char * kwnames[] = {
34545 (char *) "self",(char *) "primary", NULL
34546 };
34547
34548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34550 if (!SWIG_IsOK(res1)) {
34551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34552 }
34553 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34554 if (obj1) {
34555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34556 if (!SWIG_IsOK(ecode2)) {
34557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34558 }
34559 arg2 = static_cast< bool >(val2);
34560 }
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 (arg1)->UsePrimarySelection(arg2);
34564 wxPyEndAllowThreads(__tstate);
34565 if (PyErr_Occurred()) SWIG_fail;
34566 }
34567 resultobj = SWIG_Py_Void();
34568 return resultobj;
34569 fail:
34570 return NULL;
34571 }
34572
34573
34574 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34575 PyObject *resultobj = 0;
34576 wxClipboard *result = 0 ;
34577
34578 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34579 {
34580 PyThreadState* __tstate = wxPyBeginAllowThreads();
34581 result = (wxClipboard *)wxClipboard::Get();
34582 wxPyEndAllowThreads(__tstate);
34583 if (PyErr_Occurred()) SWIG_fail;
34584 }
34585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34586 return resultobj;
34587 fail:
34588 return NULL;
34589 }
34590
34591
34592 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34593 PyObject *obj;
34594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34595 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34596 return SWIG_Py_Void();
34597 }
34598
34599 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34600 return SWIG_Python_InitShadowInstance(args);
34601 }
34602
34603 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34604 PyObject *resultobj = 0;
34605 wxClipboard *arg1 = (wxClipboard *) NULL ;
34606 wxClipboardLocker *result = 0 ;
34607 void *argp1 = 0 ;
34608 int res1 = 0 ;
34609 PyObject * obj0 = 0 ;
34610 char * kwnames[] = {
34611 (char *) "clipboard", NULL
34612 };
34613
34614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34615 if (obj0) {
34616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34617 if (!SWIG_IsOK(res1)) {
34618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34619 }
34620 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34621 }
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34625 wxPyEndAllowThreads(__tstate);
34626 if (PyErr_Occurred()) SWIG_fail;
34627 }
34628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34629 return resultobj;
34630 fail:
34631 return NULL;
34632 }
34633
34634
34635 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34636 PyObject *resultobj = 0;
34637 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34638 void *argp1 = 0 ;
34639 int res1 = 0 ;
34640 PyObject *swig_obj[1] ;
34641
34642 if (!args) SWIG_fail;
34643 swig_obj[0] = args;
34644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34645 if (!SWIG_IsOK(res1)) {
34646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34647 }
34648 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 delete arg1;
34652
34653 wxPyEndAllowThreads(__tstate);
34654 if (PyErr_Occurred()) SWIG_fail;
34655 }
34656 resultobj = SWIG_Py_Void();
34657 return resultobj;
34658 fail:
34659 return NULL;
34660 }
34661
34662
34663 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34664 PyObject *resultobj = 0;
34665 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34666 bool result;
34667 void *argp1 = 0 ;
34668 int res1 = 0 ;
34669 PyObject *swig_obj[1] ;
34670
34671 if (!args) SWIG_fail;
34672 swig_obj[0] = args;
34673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34674 if (!SWIG_IsOK(res1)) {
34675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34676 }
34677 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34678 {
34679 PyThreadState* __tstate = wxPyBeginAllowThreads();
34680 result = (bool)wxClipboardLocker___nonzero__(arg1);
34681 wxPyEndAllowThreads(__tstate);
34682 if (PyErr_Occurred()) SWIG_fail;
34683 }
34684 {
34685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34686 }
34687 return resultobj;
34688 fail:
34689 return NULL;
34690 }
34691
34692
34693 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34694 PyObject *obj;
34695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34696 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34697 return SWIG_Py_Void();
34698 }
34699
34700 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34701 return SWIG_Python_InitShadowInstance(args);
34702 }
34703
34704 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34705 PyObject *resultobj = 0;
34706 int arg1 = (int) 0 ;
34707 int arg2 = (int) 0 ;
34708 int arg3 = (int) 0 ;
34709 int arg4 = (int) 0 ;
34710 wxVideoMode *result = 0 ;
34711 int val1 ;
34712 int ecode1 = 0 ;
34713 int val2 ;
34714 int ecode2 = 0 ;
34715 int val3 ;
34716 int ecode3 = 0 ;
34717 int val4 ;
34718 int ecode4 = 0 ;
34719 PyObject * obj0 = 0 ;
34720 PyObject * obj1 = 0 ;
34721 PyObject * obj2 = 0 ;
34722 PyObject * obj3 = 0 ;
34723 char * kwnames[] = {
34724 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34725 };
34726
34727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34728 if (obj0) {
34729 ecode1 = SWIG_AsVal_int(obj0, &val1);
34730 if (!SWIG_IsOK(ecode1)) {
34731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34732 }
34733 arg1 = static_cast< int >(val1);
34734 }
34735 if (obj1) {
34736 ecode2 = SWIG_AsVal_int(obj1, &val2);
34737 if (!SWIG_IsOK(ecode2)) {
34738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34739 }
34740 arg2 = static_cast< int >(val2);
34741 }
34742 if (obj2) {
34743 ecode3 = SWIG_AsVal_int(obj2, &val3);
34744 if (!SWIG_IsOK(ecode3)) {
34745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34746 }
34747 arg3 = static_cast< int >(val3);
34748 }
34749 if (obj3) {
34750 ecode4 = SWIG_AsVal_int(obj3, &val4);
34751 if (!SWIG_IsOK(ecode4)) {
34752 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34753 }
34754 arg4 = static_cast< int >(val4);
34755 }
34756 {
34757 PyThreadState* __tstate = wxPyBeginAllowThreads();
34758 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34759 wxPyEndAllowThreads(__tstate);
34760 if (PyErr_Occurred()) SWIG_fail;
34761 }
34762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34763 return resultobj;
34764 fail:
34765 return NULL;
34766 }
34767
34768
34769 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34770 PyObject *resultobj = 0;
34771 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34772 void *argp1 = 0 ;
34773 int res1 = 0 ;
34774 PyObject *swig_obj[1] ;
34775
34776 if (!args) SWIG_fail;
34777 swig_obj[0] = args;
34778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34779 if (!SWIG_IsOK(res1)) {
34780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34781 }
34782 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34783 {
34784 PyThreadState* __tstate = wxPyBeginAllowThreads();
34785 delete arg1;
34786
34787 wxPyEndAllowThreads(__tstate);
34788 if (PyErr_Occurred()) SWIG_fail;
34789 }
34790 resultobj = SWIG_Py_Void();
34791 return resultobj;
34792 fail:
34793 return NULL;
34794 }
34795
34796
34797 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34798 PyObject *resultobj = 0;
34799 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34800 wxVideoMode *arg2 = 0 ;
34801 bool result;
34802 void *argp1 = 0 ;
34803 int res1 = 0 ;
34804 void *argp2 = 0 ;
34805 int res2 = 0 ;
34806 PyObject * obj0 = 0 ;
34807 PyObject * obj1 = 0 ;
34808 char * kwnames[] = {
34809 (char *) "self",(char *) "other", NULL
34810 };
34811
34812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34814 if (!SWIG_IsOK(res1)) {
34815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34816 }
34817 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34818 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34819 if (!SWIG_IsOK(res2)) {
34820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34821 }
34822 if (!argp2) {
34823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34824 }
34825 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34826 {
34827 PyThreadState* __tstate = wxPyBeginAllowThreads();
34828 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34829 wxPyEndAllowThreads(__tstate);
34830 if (PyErr_Occurred()) SWIG_fail;
34831 }
34832 {
34833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34834 }
34835 return resultobj;
34836 fail:
34837 return NULL;
34838 }
34839
34840
34841 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34842 PyObject *resultobj = 0;
34843 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34844 int result;
34845 void *argp1 = 0 ;
34846 int res1 = 0 ;
34847 PyObject *swig_obj[1] ;
34848
34849 if (!args) SWIG_fail;
34850 swig_obj[0] = args;
34851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34852 if (!SWIG_IsOK(res1)) {
34853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34854 }
34855 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34856 {
34857 PyThreadState* __tstate = wxPyBeginAllowThreads();
34858 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34859 wxPyEndAllowThreads(__tstate);
34860 if (PyErr_Occurred()) SWIG_fail;
34861 }
34862 resultobj = SWIG_From_int(static_cast< int >(result));
34863 return resultobj;
34864 fail:
34865 return NULL;
34866 }
34867
34868
34869 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34870 PyObject *resultobj = 0;
34871 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34872 int result;
34873 void *argp1 = 0 ;
34874 int res1 = 0 ;
34875 PyObject *swig_obj[1] ;
34876
34877 if (!args) SWIG_fail;
34878 swig_obj[0] = args;
34879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34880 if (!SWIG_IsOK(res1)) {
34881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34882 }
34883 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34884 {
34885 PyThreadState* __tstate = wxPyBeginAllowThreads();
34886 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34887 wxPyEndAllowThreads(__tstate);
34888 if (PyErr_Occurred()) SWIG_fail;
34889 }
34890 resultobj = SWIG_From_int(static_cast< int >(result));
34891 return resultobj;
34892 fail:
34893 return NULL;
34894 }
34895
34896
34897 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34898 PyObject *resultobj = 0;
34899 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34900 int result;
34901 void *argp1 = 0 ;
34902 int res1 = 0 ;
34903 PyObject *swig_obj[1] ;
34904
34905 if (!args) SWIG_fail;
34906 swig_obj[0] = args;
34907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34908 if (!SWIG_IsOK(res1)) {
34909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34910 }
34911 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34912 {
34913 PyThreadState* __tstate = wxPyBeginAllowThreads();
34914 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34915 wxPyEndAllowThreads(__tstate);
34916 if (PyErr_Occurred()) SWIG_fail;
34917 }
34918 resultobj = SWIG_From_int(static_cast< int >(result));
34919 return resultobj;
34920 fail:
34921 return NULL;
34922 }
34923
34924
34925 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34926 PyObject *resultobj = 0;
34927 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34928 bool result;
34929 void *argp1 = 0 ;
34930 int res1 = 0 ;
34931 PyObject *swig_obj[1] ;
34932
34933 if (!args) SWIG_fail;
34934 swig_obj[0] = args;
34935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34936 if (!SWIG_IsOK(res1)) {
34937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34938 }
34939 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34940 {
34941 PyThreadState* __tstate = wxPyBeginAllowThreads();
34942 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34943 wxPyEndAllowThreads(__tstate);
34944 if (PyErr_Occurred()) SWIG_fail;
34945 }
34946 {
34947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34948 }
34949 return resultobj;
34950 fail:
34951 return NULL;
34952 }
34953
34954
34955 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34956 PyObject *resultobj = 0;
34957 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34958 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34959 bool result;
34960 void *argp1 = 0 ;
34961 int res1 = 0 ;
34962 void *argp2 = 0 ;
34963 int res2 = 0 ;
34964 PyObject * obj0 = 0 ;
34965 PyObject * obj1 = 0 ;
34966 char * kwnames[] = {
34967 (char *) "self",(char *) "other", NULL
34968 };
34969
34970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34972 if (!SWIG_IsOK(res1)) {
34973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34974 }
34975 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34977 if (!SWIG_IsOK(res2)) {
34978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34979 }
34980 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34981 {
34982 PyThreadState* __tstate = wxPyBeginAllowThreads();
34983 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34984 wxPyEndAllowThreads(__tstate);
34985 if (PyErr_Occurred()) SWIG_fail;
34986 }
34987 {
34988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34989 }
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34997 PyObject *resultobj = 0;
34998 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34999 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
35000 bool result;
35001 void *argp1 = 0 ;
35002 int res1 = 0 ;
35003 void *argp2 = 0 ;
35004 int res2 = 0 ;
35005 PyObject * obj0 = 0 ;
35006 PyObject * obj1 = 0 ;
35007 char * kwnames[] = {
35008 (char *) "self",(char *) "other", NULL
35009 };
35010
35011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
35012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35013 if (!SWIG_IsOK(res1)) {
35014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35015 }
35016 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35017 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35018 if (!SWIG_IsOK(res2)) {
35019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
35020 }
35021 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35022 {
35023 PyThreadState* __tstate = wxPyBeginAllowThreads();
35024 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
35025 wxPyEndAllowThreads(__tstate);
35026 if (PyErr_Occurred()) SWIG_fail;
35027 }
35028 {
35029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35030 }
35031 return resultobj;
35032 fail:
35033 return NULL;
35034 }
35035
35036
35037 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35038 PyObject *resultobj = 0;
35039 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35040 int arg2 ;
35041 void *argp1 = 0 ;
35042 int res1 = 0 ;
35043 int val2 ;
35044 int ecode2 = 0 ;
35045 PyObject *swig_obj[2] ;
35046
35047 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
35048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35049 if (!SWIG_IsOK(res1)) {
35050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35051 }
35052 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35053 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35054 if (!SWIG_IsOK(ecode2)) {
35055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
35056 }
35057 arg2 = static_cast< int >(val2);
35058 if (arg1) (arg1)->w = arg2;
35059
35060 resultobj = SWIG_Py_Void();
35061 return resultobj;
35062 fail:
35063 return NULL;
35064 }
35065
35066
35067 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35068 PyObject *resultobj = 0;
35069 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35070 int result;
35071 void *argp1 = 0 ;
35072 int res1 = 0 ;
35073 PyObject *swig_obj[1] ;
35074
35075 if (!args) SWIG_fail;
35076 swig_obj[0] = args;
35077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35078 if (!SWIG_IsOK(res1)) {
35079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35080 }
35081 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35082 result = (int) ((arg1)->w);
35083 resultobj = SWIG_From_int(static_cast< int >(result));
35084 return resultobj;
35085 fail:
35086 return NULL;
35087 }
35088
35089
35090 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35091 PyObject *resultobj = 0;
35092 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35093 int arg2 ;
35094 void *argp1 = 0 ;
35095 int res1 = 0 ;
35096 int val2 ;
35097 int ecode2 = 0 ;
35098 PyObject *swig_obj[2] ;
35099
35100 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
35101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35102 if (!SWIG_IsOK(res1)) {
35103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35104 }
35105 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35106 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35107 if (!SWIG_IsOK(ecode2)) {
35108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
35109 }
35110 arg2 = static_cast< int >(val2);
35111 if (arg1) (arg1)->h = arg2;
35112
35113 resultobj = SWIG_Py_Void();
35114 return resultobj;
35115 fail:
35116 return NULL;
35117 }
35118
35119
35120 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35121 PyObject *resultobj = 0;
35122 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35123 int result;
35124 void *argp1 = 0 ;
35125 int res1 = 0 ;
35126 PyObject *swig_obj[1] ;
35127
35128 if (!args) SWIG_fail;
35129 swig_obj[0] = args;
35130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35131 if (!SWIG_IsOK(res1)) {
35132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35133 }
35134 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35135 result = (int) ((arg1)->h);
35136 resultobj = SWIG_From_int(static_cast< int >(result));
35137 return resultobj;
35138 fail:
35139 return NULL;
35140 }
35141
35142
35143 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35144 PyObject *resultobj = 0;
35145 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35146 int arg2 ;
35147 void *argp1 = 0 ;
35148 int res1 = 0 ;
35149 int val2 ;
35150 int ecode2 = 0 ;
35151 PyObject *swig_obj[2] ;
35152
35153 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
35154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35155 if (!SWIG_IsOK(res1)) {
35156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35157 }
35158 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35159 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35160 if (!SWIG_IsOK(ecode2)) {
35161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
35162 }
35163 arg2 = static_cast< int >(val2);
35164 if (arg1) (arg1)->bpp = arg2;
35165
35166 resultobj = SWIG_Py_Void();
35167 return resultobj;
35168 fail:
35169 return NULL;
35170 }
35171
35172
35173 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35174 PyObject *resultobj = 0;
35175 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35176 int result;
35177 void *argp1 = 0 ;
35178 int res1 = 0 ;
35179 PyObject *swig_obj[1] ;
35180
35181 if (!args) SWIG_fail;
35182 swig_obj[0] = args;
35183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35184 if (!SWIG_IsOK(res1)) {
35185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35186 }
35187 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35188 result = (int) ((arg1)->bpp);
35189 resultobj = SWIG_From_int(static_cast< int >(result));
35190 return resultobj;
35191 fail:
35192 return NULL;
35193 }
35194
35195
35196 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35197 PyObject *resultobj = 0;
35198 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35199 int arg2 ;
35200 void *argp1 = 0 ;
35201 int res1 = 0 ;
35202 int val2 ;
35203 int ecode2 = 0 ;
35204 PyObject *swig_obj[2] ;
35205
35206 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35208 if (!SWIG_IsOK(res1)) {
35209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35210 }
35211 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35212 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35213 if (!SWIG_IsOK(ecode2)) {
35214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35215 }
35216 arg2 = static_cast< int >(val2);
35217 if (arg1) (arg1)->refresh = arg2;
35218
35219 resultobj = SWIG_Py_Void();
35220 return resultobj;
35221 fail:
35222 return NULL;
35223 }
35224
35225
35226 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35227 PyObject *resultobj = 0;
35228 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35229 int result;
35230 void *argp1 = 0 ;
35231 int res1 = 0 ;
35232 PyObject *swig_obj[1] ;
35233
35234 if (!args) SWIG_fail;
35235 swig_obj[0] = args;
35236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35237 if (!SWIG_IsOK(res1)) {
35238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35239 }
35240 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35241 result = (int) ((arg1)->refresh);
35242 resultobj = SWIG_From_int(static_cast< int >(result));
35243 return resultobj;
35244 fail:
35245 return NULL;
35246 }
35247
35248
35249 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35250 PyObject *obj;
35251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35252 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35253 return SWIG_Py_Void();
35254 }
35255
35256 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35257 return SWIG_Python_InitShadowInstance(args);
35258 }
35259
35260 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35261 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35262 return 1;
35263 }
35264
35265
35266 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35267 PyObject *pyobj = 0;
35268
35269 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35270 return pyobj;
35271 }
35272
35273
35274 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35275 PyObject *resultobj = 0;
35276 size_t arg1 = (size_t) 0 ;
35277 wxDisplay *result = 0 ;
35278 size_t val1 ;
35279 int ecode1 = 0 ;
35280 PyObject * obj0 = 0 ;
35281 char * kwnames[] = {
35282 (char *) "index", NULL
35283 };
35284
35285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35286 if (obj0) {
35287 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35288 if (!SWIG_IsOK(ecode1)) {
35289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35290 }
35291 arg1 = static_cast< size_t >(val1);
35292 }
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 result = (wxDisplay *)new wxDisplay(arg1);
35296 wxPyEndAllowThreads(__tstate);
35297 if (PyErr_Occurred()) SWIG_fail;
35298 }
35299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35300 return resultobj;
35301 fail:
35302 return NULL;
35303 }
35304
35305
35306 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35307 PyObject *resultobj = 0;
35308 wxDisplay *arg1 = (wxDisplay *) 0 ;
35309 void *argp1 = 0 ;
35310 int res1 = 0 ;
35311 PyObject *swig_obj[1] ;
35312
35313 if (!args) SWIG_fail;
35314 swig_obj[0] = args;
35315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35316 if (!SWIG_IsOK(res1)) {
35317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35318 }
35319 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35320 {
35321 PyThreadState* __tstate = wxPyBeginAllowThreads();
35322 delete arg1;
35323
35324 wxPyEndAllowThreads(__tstate);
35325 if (PyErr_Occurred()) SWIG_fail;
35326 }
35327 resultobj = SWIG_Py_Void();
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35335 PyObject *resultobj = 0;
35336 size_t result;
35337
35338 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35339 {
35340 PyThreadState* __tstate = wxPyBeginAllowThreads();
35341 result = (size_t)wxDisplay::GetCount();
35342 wxPyEndAllowThreads(__tstate);
35343 if (PyErr_Occurred()) SWIG_fail;
35344 }
35345 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35346 return resultobj;
35347 fail:
35348 return NULL;
35349 }
35350
35351
35352 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35353 PyObject *resultobj = 0;
35354 wxPoint *arg1 = 0 ;
35355 int result;
35356 wxPoint temp1 ;
35357 PyObject * obj0 = 0 ;
35358 char * kwnames[] = {
35359 (char *) "pt", NULL
35360 };
35361
35362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35363 {
35364 arg1 = &temp1;
35365 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35366 }
35367 {
35368 PyThreadState* __tstate = wxPyBeginAllowThreads();
35369 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 resultobj = SWIG_From_int(static_cast< int >(result));
35374 return resultobj;
35375 fail:
35376 return NULL;
35377 }
35378
35379
35380 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35381 PyObject *resultobj = 0;
35382 wxWindow *arg1 = (wxWindow *) 0 ;
35383 int result;
35384 void *argp1 = 0 ;
35385 int res1 = 0 ;
35386 PyObject * obj0 = 0 ;
35387 char * kwnames[] = {
35388 (char *) "window", NULL
35389 };
35390
35391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35393 if (!SWIG_IsOK(res1)) {
35394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35395 }
35396 arg1 = reinterpret_cast< wxWindow * >(argp1);
35397 {
35398 PyThreadState* __tstate = wxPyBeginAllowThreads();
35399 result = (int)wxDisplay::GetFromWindow(arg1);
35400 wxPyEndAllowThreads(__tstate);
35401 if (PyErr_Occurred()) SWIG_fail;
35402 }
35403 resultobj = SWIG_From_int(static_cast< int >(result));
35404 return resultobj;
35405 fail:
35406 return NULL;
35407 }
35408
35409
35410 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35411 PyObject *resultobj = 0;
35412 wxDisplay *arg1 = (wxDisplay *) 0 ;
35413 bool result;
35414 void *argp1 = 0 ;
35415 int res1 = 0 ;
35416 PyObject *swig_obj[1] ;
35417
35418 if (!args) SWIG_fail;
35419 swig_obj[0] = args;
35420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35421 if (!SWIG_IsOK(res1)) {
35422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35423 }
35424 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35425 {
35426 PyThreadState* __tstate = wxPyBeginAllowThreads();
35427 result = (bool)((wxDisplay const *)arg1)->IsOk();
35428 wxPyEndAllowThreads(__tstate);
35429 if (PyErr_Occurred()) SWIG_fail;
35430 }
35431 {
35432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35433 }
35434 return resultobj;
35435 fail:
35436 return NULL;
35437 }
35438
35439
35440 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35441 PyObject *resultobj = 0;
35442 wxDisplay *arg1 = (wxDisplay *) 0 ;
35443 wxRect result;
35444 void *argp1 = 0 ;
35445 int res1 = 0 ;
35446 PyObject *swig_obj[1] ;
35447
35448 if (!args) SWIG_fail;
35449 swig_obj[0] = args;
35450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35451 if (!SWIG_IsOK(res1)) {
35452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35453 }
35454 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35455 {
35456 PyThreadState* __tstate = wxPyBeginAllowThreads();
35457 result = ((wxDisplay const *)arg1)->GetGeometry();
35458 wxPyEndAllowThreads(__tstate);
35459 if (PyErr_Occurred()) SWIG_fail;
35460 }
35461 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35462 return resultobj;
35463 fail:
35464 return NULL;
35465 }
35466
35467
35468 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35469 PyObject *resultobj = 0;
35470 wxDisplay *arg1 = (wxDisplay *) 0 ;
35471 wxRect result;
35472 void *argp1 = 0 ;
35473 int res1 = 0 ;
35474 PyObject *swig_obj[1] ;
35475
35476 if (!args) SWIG_fail;
35477 swig_obj[0] = args;
35478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35479 if (!SWIG_IsOK(res1)) {
35480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35481 }
35482 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35483 {
35484 PyThreadState* __tstate = wxPyBeginAllowThreads();
35485 result = ((wxDisplay const *)arg1)->GetClientArea();
35486 wxPyEndAllowThreads(__tstate);
35487 if (PyErr_Occurred()) SWIG_fail;
35488 }
35489 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35490 return resultobj;
35491 fail:
35492 return NULL;
35493 }
35494
35495
35496 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35497 PyObject *resultobj = 0;
35498 wxDisplay *arg1 = (wxDisplay *) 0 ;
35499 wxString result;
35500 void *argp1 = 0 ;
35501 int res1 = 0 ;
35502 PyObject *swig_obj[1] ;
35503
35504 if (!args) SWIG_fail;
35505 swig_obj[0] = args;
35506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35507 if (!SWIG_IsOK(res1)) {
35508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35509 }
35510 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35511 {
35512 PyThreadState* __tstate = wxPyBeginAllowThreads();
35513 result = ((wxDisplay const *)arg1)->GetName();
35514 wxPyEndAllowThreads(__tstate);
35515 if (PyErr_Occurred()) SWIG_fail;
35516 }
35517 {
35518 #if wxUSE_UNICODE
35519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35520 #else
35521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35522 #endif
35523 }
35524 return resultobj;
35525 fail:
35526 return NULL;
35527 }
35528
35529
35530 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35531 PyObject *resultobj = 0;
35532 wxDisplay *arg1 = (wxDisplay *) 0 ;
35533 bool result;
35534 void *argp1 = 0 ;
35535 int res1 = 0 ;
35536 PyObject *swig_obj[1] ;
35537
35538 if (!args) SWIG_fail;
35539 swig_obj[0] = args;
35540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35541 if (!SWIG_IsOK(res1)) {
35542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35543 }
35544 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 {
35552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35553 }
35554 return resultobj;
35555 fail:
35556 return NULL;
35557 }
35558
35559
35560 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35561 PyObject *resultobj = 0;
35562 wxDisplay *arg1 = (wxDisplay *) 0 ;
35563 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35564 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35565 PyObject *result = 0 ;
35566 void *argp1 = 0 ;
35567 int res1 = 0 ;
35568 void *argp2 = 0 ;
35569 int res2 = 0 ;
35570 PyObject * obj0 = 0 ;
35571 PyObject * obj1 = 0 ;
35572 char * kwnames[] = {
35573 (char *) "self",(char *) "mode", NULL
35574 };
35575
35576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35578 if (!SWIG_IsOK(res1)) {
35579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35580 }
35581 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35582 if (obj1) {
35583 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35584 if (!SWIG_IsOK(res2)) {
35585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35586 }
35587 if (!argp2) {
35588 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35589 }
35590 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35591 }
35592 {
35593 PyThreadState* __tstate = wxPyBeginAllowThreads();
35594 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35595 wxPyEndAllowThreads(__tstate);
35596 if (PyErr_Occurred()) SWIG_fail;
35597 }
35598 resultobj = result;
35599 return resultobj;
35600 fail:
35601 return NULL;
35602 }
35603
35604
35605 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35606 PyObject *resultobj = 0;
35607 wxDisplay *arg1 = (wxDisplay *) 0 ;
35608 wxVideoMode result;
35609 void *argp1 = 0 ;
35610 int res1 = 0 ;
35611 PyObject *swig_obj[1] ;
35612
35613 if (!args) SWIG_fail;
35614 swig_obj[0] = args;
35615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35616 if (!SWIG_IsOK(res1)) {
35617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35618 }
35619 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35620 {
35621 PyThreadState* __tstate = wxPyBeginAllowThreads();
35622 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35623 wxPyEndAllowThreads(__tstate);
35624 if (PyErr_Occurred()) SWIG_fail;
35625 }
35626 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35627 return resultobj;
35628 fail:
35629 return NULL;
35630 }
35631
35632
35633 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35634 PyObject *resultobj = 0;
35635 wxDisplay *arg1 = (wxDisplay *) 0 ;
35636 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35637 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35638 bool result;
35639 void *argp1 = 0 ;
35640 int res1 = 0 ;
35641 void *argp2 = 0 ;
35642 int res2 = 0 ;
35643 PyObject * obj0 = 0 ;
35644 PyObject * obj1 = 0 ;
35645 char * kwnames[] = {
35646 (char *) "self",(char *) "mode", NULL
35647 };
35648
35649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35651 if (!SWIG_IsOK(res1)) {
35652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35653 }
35654 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35655 if (obj1) {
35656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35657 if (!SWIG_IsOK(res2)) {
35658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35659 }
35660 if (!argp2) {
35661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35662 }
35663 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35664 }
35665 {
35666 PyThreadState* __tstate = wxPyBeginAllowThreads();
35667 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35668 wxPyEndAllowThreads(__tstate);
35669 if (PyErr_Occurred()) SWIG_fail;
35670 }
35671 {
35672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35673 }
35674 return resultobj;
35675 fail:
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35681 PyObject *resultobj = 0;
35682 wxDisplay *arg1 = (wxDisplay *) 0 ;
35683 void *argp1 = 0 ;
35684 int res1 = 0 ;
35685 PyObject *swig_obj[1] ;
35686
35687 if (!args) SWIG_fail;
35688 swig_obj[0] = args;
35689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35690 if (!SWIG_IsOK(res1)) {
35691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35692 }
35693 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35694 {
35695 PyThreadState* __tstate = wxPyBeginAllowThreads();
35696 wxDisplay_ResetMode(arg1);
35697 wxPyEndAllowThreads(__tstate);
35698 if (PyErr_Occurred()) SWIG_fail;
35699 }
35700 resultobj = SWIG_Py_Void();
35701 return resultobj;
35702 fail:
35703 return NULL;
35704 }
35705
35706
35707 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35708 PyObject *obj;
35709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35710 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35711 return SWIG_Py_Void();
35712 }
35713
35714 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35715 return SWIG_Python_InitShadowInstance(args);
35716 }
35717
35718 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35719 PyObject *resultobj = 0;
35720 wxStandardPaths *result = 0 ;
35721
35722 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35723 {
35724 PyThreadState* __tstate = wxPyBeginAllowThreads();
35725 result = (wxStandardPaths *)wxStandardPaths_Get();
35726 wxPyEndAllowThreads(__tstate);
35727 if (PyErr_Occurred()) SWIG_fail;
35728 }
35729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35730 return resultobj;
35731 fail:
35732 return NULL;
35733 }
35734
35735
35736 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35737 PyObject *resultobj = 0;
35738 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35739 wxString result;
35740 void *argp1 = 0 ;
35741 int res1 = 0 ;
35742 PyObject *swig_obj[1] ;
35743
35744 if (!args) SWIG_fail;
35745 swig_obj[0] = args;
35746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35747 if (!SWIG_IsOK(res1)) {
35748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35749 }
35750 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35751 {
35752 PyThreadState* __tstate = wxPyBeginAllowThreads();
35753 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35754 wxPyEndAllowThreads(__tstate);
35755 if (PyErr_Occurred()) SWIG_fail;
35756 }
35757 {
35758 #if wxUSE_UNICODE
35759 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35760 #else
35761 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35762 #endif
35763 }
35764 return resultobj;
35765 fail:
35766 return NULL;
35767 }
35768
35769
35770 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35771 PyObject *resultobj = 0;
35772 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35773 wxString result;
35774 void *argp1 = 0 ;
35775 int res1 = 0 ;
35776 PyObject *swig_obj[1] ;
35777
35778 if (!args) SWIG_fail;
35779 swig_obj[0] = args;
35780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35781 if (!SWIG_IsOK(res1)) {
35782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35783 }
35784 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 {
35792 #if wxUSE_UNICODE
35793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35794 #else
35795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35796 #endif
35797 }
35798 return resultobj;
35799 fail:
35800 return NULL;
35801 }
35802
35803
35804 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35805 PyObject *resultobj = 0;
35806 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35807 wxString result;
35808 void *argp1 = 0 ;
35809 int res1 = 0 ;
35810 PyObject *swig_obj[1] ;
35811
35812 if (!args) SWIG_fail;
35813 swig_obj[0] = args;
35814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35815 if (!SWIG_IsOK(res1)) {
35816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35817 }
35818 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35819 {
35820 PyThreadState* __tstate = wxPyBeginAllowThreads();
35821 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35822 wxPyEndAllowThreads(__tstate);
35823 if (PyErr_Occurred()) SWIG_fail;
35824 }
35825 {
35826 #if wxUSE_UNICODE
35827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35828 #else
35829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35830 #endif
35831 }
35832 return resultobj;
35833 fail:
35834 return NULL;
35835 }
35836
35837
35838 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35839 PyObject *resultobj = 0;
35840 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35841 wxString result;
35842 void *argp1 = 0 ;
35843 int res1 = 0 ;
35844 PyObject *swig_obj[1] ;
35845
35846 if (!args) SWIG_fail;
35847 swig_obj[0] = args;
35848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35849 if (!SWIG_IsOK(res1)) {
35850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35851 }
35852 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35853 {
35854 PyThreadState* __tstate = wxPyBeginAllowThreads();
35855 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35856 wxPyEndAllowThreads(__tstate);
35857 if (PyErr_Occurred()) SWIG_fail;
35858 }
35859 {
35860 #if wxUSE_UNICODE
35861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35862 #else
35863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35864 #endif
35865 }
35866 return resultobj;
35867 fail:
35868 return NULL;
35869 }
35870
35871
35872 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35873 PyObject *resultobj = 0;
35874 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35875 wxString result;
35876 void *argp1 = 0 ;
35877 int res1 = 0 ;
35878 PyObject *swig_obj[1] ;
35879
35880 if (!args) SWIG_fail;
35881 swig_obj[0] = args;
35882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35883 if (!SWIG_IsOK(res1)) {
35884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35885 }
35886 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35887 {
35888 PyThreadState* __tstate = wxPyBeginAllowThreads();
35889 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35890 wxPyEndAllowThreads(__tstate);
35891 if (PyErr_Occurred()) SWIG_fail;
35892 }
35893 {
35894 #if wxUSE_UNICODE
35895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35896 #else
35897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35898 #endif
35899 }
35900 return resultobj;
35901 fail:
35902 return NULL;
35903 }
35904
35905
35906 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35907 PyObject *resultobj = 0;
35908 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35909 wxString result;
35910 void *argp1 = 0 ;
35911 int res1 = 0 ;
35912 PyObject *swig_obj[1] ;
35913
35914 if (!args) SWIG_fail;
35915 swig_obj[0] = args;
35916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35917 if (!SWIG_IsOK(res1)) {
35918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35919 }
35920 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35921 {
35922 PyThreadState* __tstate = wxPyBeginAllowThreads();
35923 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35924 wxPyEndAllowThreads(__tstate);
35925 if (PyErr_Occurred()) SWIG_fail;
35926 }
35927 {
35928 #if wxUSE_UNICODE
35929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35930 #else
35931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35932 #endif
35933 }
35934 return resultobj;
35935 fail:
35936 return NULL;
35937 }
35938
35939
35940 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35941 PyObject *resultobj = 0;
35942 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35943 wxString result;
35944 void *argp1 = 0 ;
35945 int res1 = 0 ;
35946 PyObject *swig_obj[1] ;
35947
35948 if (!args) SWIG_fail;
35949 swig_obj[0] = args;
35950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35951 if (!SWIG_IsOK(res1)) {
35952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35953 }
35954 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35955 {
35956 PyThreadState* __tstate = wxPyBeginAllowThreads();
35957 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35958 wxPyEndAllowThreads(__tstate);
35959 if (PyErr_Occurred()) SWIG_fail;
35960 }
35961 {
35962 #if wxUSE_UNICODE
35963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35964 #else
35965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35966 #endif
35967 }
35968 return resultobj;
35969 fail:
35970 return NULL;
35971 }
35972
35973
35974 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35975 PyObject *resultobj = 0;
35976 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35977 wxString result;
35978 void *argp1 = 0 ;
35979 int res1 = 0 ;
35980 PyObject *swig_obj[1] ;
35981
35982 if (!args) SWIG_fail;
35983 swig_obj[0] = args;
35984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35985 if (!SWIG_IsOK(res1)) {
35986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35987 }
35988 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35989 {
35990 PyThreadState* __tstate = wxPyBeginAllowThreads();
35991 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35992 wxPyEndAllowThreads(__tstate);
35993 if (PyErr_Occurred()) SWIG_fail;
35994 }
35995 {
35996 #if wxUSE_UNICODE
35997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35998 #else
35999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36000 #endif
36001 }
36002 return resultobj;
36003 fail:
36004 return NULL;
36005 }
36006
36007
36008 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36009 PyObject *resultobj = 0;
36010 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36011 wxString *arg2 = 0 ;
36012 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
36013 wxString result;
36014 void *argp1 = 0 ;
36015 int res1 = 0 ;
36016 bool temp2 = false ;
36017 int val3 ;
36018 int ecode3 = 0 ;
36019 PyObject * obj0 = 0 ;
36020 PyObject * obj1 = 0 ;
36021 PyObject * obj2 = 0 ;
36022 char * kwnames[] = {
36023 (char *) "self",(char *) "lang",(char *) "category", NULL
36024 };
36025
36026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36030 }
36031 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36032 {
36033 arg2 = wxString_in_helper(obj1);
36034 if (arg2 == NULL) SWIG_fail;
36035 temp2 = true;
36036 }
36037 if (obj2) {
36038 ecode3 = SWIG_AsVal_int(obj2, &val3);
36039 if (!SWIG_IsOK(ecode3)) {
36040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
36041 }
36042 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
36043 }
36044 {
36045 PyThreadState* __tstate = wxPyBeginAllowThreads();
36046 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
36047 wxPyEndAllowThreads(__tstate);
36048 if (PyErr_Occurred()) SWIG_fail;
36049 }
36050 {
36051 #if wxUSE_UNICODE
36052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36053 #else
36054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36055 #endif
36056 }
36057 {
36058 if (temp2)
36059 delete arg2;
36060 }
36061 return resultobj;
36062 fail:
36063 {
36064 if (temp2)
36065 delete arg2;
36066 }
36067 return NULL;
36068 }
36069
36070
36071 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36072 PyObject *resultobj = 0;
36073 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36074 wxString result;
36075 void *argp1 = 0 ;
36076 int res1 = 0 ;
36077 PyObject *swig_obj[1] ;
36078
36079 if (!args) SWIG_fail;
36080 swig_obj[0] = args;
36081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36082 if (!SWIG_IsOK(res1)) {
36083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36084 }
36085 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36086 {
36087 PyThreadState* __tstate = wxPyBeginAllowThreads();
36088 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
36089 wxPyEndAllowThreads(__tstate);
36090 if (PyErr_Occurred()) SWIG_fail;
36091 }
36092 {
36093 #if wxUSE_UNICODE
36094 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36095 #else
36096 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36097 #endif
36098 }
36099 return resultobj;
36100 fail:
36101 return NULL;
36102 }
36103
36104
36105 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36106 PyObject *resultobj = 0;
36107 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36108 wxString *arg2 = 0 ;
36109 void *argp1 = 0 ;
36110 int res1 = 0 ;
36111 bool temp2 = false ;
36112 PyObject * obj0 = 0 ;
36113 PyObject * obj1 = 0 ;
36114 char * kwnames[] = {
36115 (char *) "self",(char *) "prefix", NULL
36116 };
36117
36118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
36119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36120 if (!SWIG_IsOK(res1)) {
36121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36122 }
36123 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36124 {
36125 arg2 = wxString_in_helper(obj1);
36126 if (arg2 == NULL) SWIG_fail;
36127 temp2 = true;
36128 }
36129 {
36130 PyThreadState* __tstate = wxPyBeginAllowThreads();
36131 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
36132 wxPyEndAllowThreads(__tstate);
36133 if (PyErr_Occurred()) SWIG_fail;
36134 }
36135 resultobj = SWIG_Py_Void();
36136 {
36137 if (temp2)
36138 delete arg2;
36139 }
36140 return resultobj;
36141 fail:
36142 {
36143 if (temp2)
36144 delete arg2;
36145 }
36146 return NULL;
36147 }
36148
36149
36150 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36151 PyObject *resultobj = 0;
36152 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36153 wxString result;
36154 void *argp1 = 0 ;
36155 int res1 = 0 ;
36156 PyObject *swig_obj[1] ;
36157
36158 if (!args) SWIG_fail;
36159 swig_obj[0] = args;
36160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36161 if (!SWIG_IsOK(res1)) {
36162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36163 }
36164 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36165 {
36166 PyThreadState* __tstate = wxPyBeginAllowThreads();
36167 result = wxStandardPaths_GetInstallPrefix(arg1);
36168 wxPyEndAllowThreads(__tstate);
36169 if (PyErr_Occurred()) SWIG_fail;
36170 }
36171 {
36172 #if wxUSE_UNICODE
36173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36174 #else
36175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36176 #endif
36177 }
36178 return resultobj;
36179 fail:
36180 return NULL;
36181 }
36182
36183
36184 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36185 PyObject *obj;
36186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36187 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36188 return SWIG_Py_Void();
36189 }
36190
36191 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36192 PyObject *resultobj = 0;
36193 wxEventType arg1 ;
36194 wxPowerEvent *result = 0 ;
36195 int val1 ;
36196 int ecode1 = 0 ;
36197 PyObject * obj0 = 0 ;
36198 char * kwnames[] = {
36199 (char *) "evtType", NULL
36200 };
36201
36202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36203 ecode1 = SWIG_AsVal_int(obj0, &val1);
36204 if (!SWIG_IsOK(ecode1)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36206 }
36207 arg1 = static_cast< wxEventType >(val1);
36208 {
36209 PyThreadState* __tstate = wxPyBeginAllowThreads();
36210 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36211 wxPyEndAllowThreads(__tstate);
36212 if (PyErr_Occurred()) SWIG_fail;
36213 }
36214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36222 PyObject *resultobj = 0;
36223 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36224 void *argp1 = 0 ;
36225 int res1 = 0 ;
36226 PyObject *swig_obj[1] ;
36227
36228 if (!args) SWIG_fail;
36229 swig_obj[0] = args;
36230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36231 if (!SWIG_IsOK(res1)) {
36232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36233 }
36234 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 (arg1)->Veto();
36238 wxPyEndAllowThreads(__tstate);
36239 if (PyErr_Occurred()) SWIG_fail;
36240 }
36241 resultobj = SWIG_Py_Void();
36242 return resultobj;
36243 fail:
36244 return NULL;
36245 }
36246
36247
36248 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36249 PyObject *resultobj = 0;
36250 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36251 bool 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_wxPowerEvent, 0 | 0 );
36259 if (!SWIG_IsOK(res1)) {
36260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36261 }
36262 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36263 {
36264 PyThreadState* __tstate = wxPyBeginAllowThreads();
36265 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36266 wxPyEndAllowThreads(__tstate);
36267 if (PyErr_Occurred()) SWIG_fail;
36268 }
36269 {
36270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36271 }
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36279 PyObject *obj;
36280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36281 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36282 return SWIG_Py_Void();
36283 }
36284
36285 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36286 return SWIG_Python_InitShadowInstance(args);
36287 }
36288
36289 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36290 PyObject *resultobj = 0;
36291 wxPowerType result;
36292
36293 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36294 {
36295 PyThreadState* __tstate = wxPyBeginAllowThreads();
36296 result = (wxPowerType)wxGetPowerType();
36297 wxPyEndAllowThreads(__tstate);
36298 if (PyErr_Occurred()) SWIG_fail;
36299 }
36300 resultobj = SWIG_From_int(static_cast< int >(result));
36301 return resultobj;
36302 fail:
36303 return NULL;
36304 }
36305
36306
36307 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36308 PyObject *resultobj = 0;
36309 wxBatteryState result;
36310
36311 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 result = (wxBatteryState)wxGetBatteryState();
36315 wxPyEndAllowThreads(__tstate);
36316 if (PyErr_Occurred()) SWIG_fail;
36317 }
36318 resultobj = SWIG_From_int(static_cast< int >(result));
36319 return resultobj;
36320 fail:
36321 return NULL;
36322 }
36323
36324
36325 static PyMethodDef SwigMethods[] = {
36326 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36331 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36332 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36333 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36334 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36335 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36336 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36337 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36341 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36342 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36343 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36345 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36347 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36349 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36350 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36351 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36352 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36353 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36354 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36355 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36356 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36357 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36358 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36365 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36366 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36367 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36368 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36369 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36370 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36371 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36372 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36373 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36384 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36385 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36386 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36387 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36388 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36389 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36390 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36391 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36392 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36393 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36394 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36396 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36397 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36398 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36399 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36402 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36404 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36405 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36406 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36407 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36408 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36409 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36410 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36411 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36412 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36413 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36414 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36415 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36419 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36420 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36425 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36426 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36427 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36428 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36429 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36430 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36431 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36432 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36433 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36434 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36435 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36436 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36437 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36438 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36439 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36440 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36443 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36444 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36446 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36447 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36448 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36449 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36450 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36451 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36452 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36453 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36454 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36455 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36458 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36460 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36461 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36463 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36464 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36466 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36467 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36468 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36470 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36471 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36472 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36473 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36474 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36475 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36476 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36477 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36479 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36480 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36481 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36482 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36483 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36485 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36488 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36493 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36495 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36496 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36497 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36498 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36500 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36501 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36502 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36503 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36504 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36505 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36506 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36507 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36508 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36509 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36510 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36511 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36514 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36515 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36519 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36522 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36524 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36525 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36526 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36527 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36528 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36529 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36530 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36531 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36533 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36534 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36535 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36536 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36537 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36539 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36540 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36541 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36542 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36543 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36546 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36547 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36548 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36550 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36551 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36554 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
36556 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36560 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36561 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36563 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36564 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36565 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36566 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36567 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36568 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36569 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36570 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36571 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36572 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36573 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36574 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36576 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36577 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36578 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36579 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36580 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36583 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36584 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36585 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36587 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36588 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36592 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36593 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36594 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36595 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36596 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36597 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36598 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36599 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36600 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36601 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36606 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36607 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36608 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36613 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36615 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36616 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36617 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36618 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36619 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36621 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36622 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36623 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36629 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36630 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36631 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36632 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36633 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36634 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36635 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36636 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36637 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36638 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36639 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36640 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36641 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36642 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36643 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36644 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36645 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36646 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36647 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36648 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36649 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36650 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36653 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36654 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36655 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36656 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36657 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36658 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36659 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36660 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36661 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36662 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36664 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36665 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36666 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36667 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36668 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36669 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36670 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36671 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36672 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36673 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36674 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36675 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36676 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36677 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36678 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36679 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36680 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36681 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36682 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36683 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36684 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36685 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36686 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36687 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36688 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36689 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36690 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36691 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36692 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36693 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36695 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36696 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36697 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36699 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36700 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36701 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36702 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36703 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36709 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36710 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36711 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36715 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36716 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36717 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36718 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36719 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36720 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36721 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36722 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36723 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36725 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36726 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36727 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36728 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36730 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36731 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36734 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36735 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36736 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36737 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36738 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36739 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36740 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36741 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36742 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36743 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36744 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36746 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36747 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36748 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36749 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36750 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36751 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36752 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36758 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36760 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36761 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36763 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36765 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36770 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36771 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36773 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36774 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36775 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36776 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36777 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36778 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36781 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36782 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36783 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36784 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36786 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36787 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36788 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36789 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36790 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36792 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36793 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36795 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36796 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36798 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36805 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36814 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36819 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36821 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36823 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36825 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36826 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36827 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36830 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36831 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36833 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36834 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36835 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36837 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36838 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36839 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36841 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36842 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36843 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36844 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36845 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36846 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36847 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36848 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36849 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36850 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36854 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36857 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36858 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36862 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36863 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36864 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36865 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36866 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36871 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36872 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36874 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36875 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36877 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36878 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36881 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36882 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36883 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36885 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36886 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36887 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36889 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36891 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36896 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36898 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36900 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36901 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36902 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36903 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36904 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36905 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36906 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36907 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36909 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36910 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36911 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36913 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36914 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36915 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36916 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36917 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36918 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36919 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36920 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36922 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36923 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36926 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36927 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36928 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36929 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36930 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36931 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36933 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36935 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36936 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36938 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36939 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36940 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36941 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36942 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36943 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36944 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36945 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36946 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36947 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36948 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36949 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36950 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36951 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36952 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36953 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36954 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36955 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36956 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36957 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36958 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36959 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36960 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36961 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36962 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36963 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36964 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36965 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36966 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36967 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36968 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36969 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36970 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36971 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36972 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36973 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36974 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36975 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36976 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36977 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36978 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36979 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36980 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36982 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36983 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36984 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36985 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36986 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36988 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36989 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36990 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36991 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36992 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36993 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36994 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36995 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36996 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36997 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36998 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36999 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
37000 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
37001 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
37002 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
37003 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
37004 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
37005 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
37006 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
37007 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
37008 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
37009 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
37010 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
37011 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
37012 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
37013 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
37014 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
37015 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
37016 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
37017 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
37018 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
37019 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
37020 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
37021 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
37022 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
37023 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
37024 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
37025 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
37026 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
37027 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
37028 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
37029 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
37030 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
37031 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
37032 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37033 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
37034 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
37035 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
37036 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
37037 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
37038 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
37039 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
37040 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
37041 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
37042 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
37043 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
37044 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37045 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37046 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
37047 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
37048 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
37049 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
37050 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
37051 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
37052 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37053 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37054 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
37055 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
37056 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
37057 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
37058 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
37059 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
37060 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
37061 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
37062 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
37063 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
37064 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37065 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
37066 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37067 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
37068 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
37069 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
37070 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37071 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
37072 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37073 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
37074 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37075 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
37076 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
37077 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37078 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
37079 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
37080 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37081 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37082 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
37083 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
37084 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
37085 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37086 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
37087 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
37088 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
37089 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37090 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
37091 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
37092 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
37093 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
37094 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
37095 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37096 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37097 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
37098 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
37099 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37100 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
37101 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37102 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
37103 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
37104 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37105 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37106 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
37107 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
37108 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
37109 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
37110 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
37111 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
37112 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
37113 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
37114 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37115 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
37116 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
37117 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
37118 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
37119 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
37120 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
37121 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
37122 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
37123 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
37124 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
37125 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
37126 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
37127 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
37128 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
37129 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
37130 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
37131 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37132 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
37133 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37134 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
37135 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37136 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37137 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
37138 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
37139 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
37140 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37141 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37142 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
37143 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
37144 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37145 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37146 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37147 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
37148 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37149 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
37150 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
37151 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
37152 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
37153 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
37154 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
37155 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37156 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
37157 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37158 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37159 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
37160 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37161 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37162 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
37163 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
37164 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
37165 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37166 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
37167 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37168 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37169 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
37170 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37171 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37172 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
37173 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
37174 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
37175 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
37176 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
37177 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
37178 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
37179 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
37180 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37181 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37182 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37183 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37184 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37185 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37186 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37187 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37188 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37189 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37190 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37191 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37192 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37193 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37194 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37195 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37196 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37197 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37198 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37199 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37200 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37201 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37202 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37203 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37204 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37205 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37206 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37207 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37208 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37209 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37210 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37211 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37212 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37213 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37214 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37215 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37216 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37217 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37218 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37219 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37220 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37221 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37222 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37223 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37224 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37225 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37226 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37227 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37228 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37229 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37230 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37231 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37232 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37233 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37234 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37235 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37236 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37237 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37238 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37239 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37240 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37241 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37242 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37243 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37244 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37245 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37246 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37247 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37248 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37249 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37250 { NULL, NULL, 0, NULL }
37251 };
37252
37253
37254 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37255
37256 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37257 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37258 }
37259 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37260 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37261 }
37262 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37263 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37264 }
37265 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37266 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37267 }
37268 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37269 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37270 }
37271 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37272 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37273 }
37274 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37275 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37276 }
37277 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37278 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37279 }
37280 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37281 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37282 }
37283 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37284 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37285 }
37286 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37287 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37288 }
37289 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37290 return (void *)((wxEvent *) ((wxPyEvent *) x));
37291 }
37292 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37293 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37294 }
37295 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37296 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37297 }
37298 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37299 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37300 }
37301 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37302 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37303 }
37304 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37305 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37306 }
37307 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37308 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37309 }
37310 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37311 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37312 }
37313 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37314 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37315 }
37316 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37317 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37318 }
37319 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37320 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37321 }
37322 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37323 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37324 }
37325 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37326 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37327 }
37328 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37329 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37330 }
37331 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37332 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37333 }
37334 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37335 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37336 }
37337 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37338 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37339 }
37340 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37341 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37342 }
37343 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37344 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37345 }
37346 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37347 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37348 }
37349 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37350 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37351 }
37352 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37353 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37354 }
37355 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37356 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37357 }
37358 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37359 return (void *)((wxEvent *) ((wxShowEvent *) x));
37360 }
37361 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37362 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37363 }
37364 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37365 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37366 }
37367 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37368 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37369 }
37370 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37371 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37372 }
37373 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37374 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37375 }
37376 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37377 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37378 }
37379 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37380 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37381 }
37382 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37383 return (void *)((wxConfigBase *) ((wxConfig *) x));
37384 }
37385 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37386 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37387 }
37388 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37389 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37390 }
37391 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37392 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37393 }
37394 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37395 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37396 }
37397 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37398 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37399 }
37400 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37401 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37402 }
37403 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37404 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37405 }
37406 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37407 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37408 }
37409 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37410 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37411 }
37412 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37413 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37414 }
37415 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37416 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37417 }
37418 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37419 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37420 }
37421 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37422 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37423 }
37424 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37425 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37426 }
37427 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37428 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37429 }
37430 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37431 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37432 }
37433 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37434 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37435 }
37436 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37437 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37438 }
37439 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37440 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37441 }
37442 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37443 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37444 }
37445 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37446 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37447 }
37448 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37449 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37450 }
37451 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37452 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37453 }
37454 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37455 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37456 }
37457 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37458 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37459 }
37460 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37461 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37462 }
37463 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37464 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37465 }
37466 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37467 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37468 }
37469 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37470 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37471 }
37472 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37473 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37474 }
37475 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37476 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37477 }
37478 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37479 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37480 }
37481 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37482 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37483 }
37484 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37485 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37486 }
37487 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37488 return (void *)((wxObject *) ((wxSizerItem *) x));
37489 }
37490 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37491 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37492 }
37493 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37494 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37495 }
37496 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37497 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37498 }
37499 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37500 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37501 }
37502 static void *_p_wxSizerTo_p_wxObject(void *x) {
37503 return (void *)((wxObject *) ((wxSizer *) x));
37504 }
37505 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37506 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37507 }
37508 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37509 return (void *)((wxObject *) ((wxFileHistory *) x));
37510 }
37511 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37512 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37513 }
37514 static void *_p_wxEventTo_p_wxObject(void *x) {
37515 return (void *)((wxObject *) ((wxEvent *) x));
37516 }
37517 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37518 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37519 }
37520 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37521 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37522 }
37523 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37524 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37525 }
37526 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37527 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37528 }
37529 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37530 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37531 }
37532 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37533 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37534 }
37535 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37536 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37537 }
37538 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37539 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37540 }
37541 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37542 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37543 }
37544 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37545 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37546 }
37547 static void *_p_wxControlTo_p_wxObject(void *x) {
37548 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37549 }
37550 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37551 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37552 }
37553 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37554 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37555 }
37556 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37557 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37558 }
37559 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37560 return (void *)((wxObject *) ((wxFSFile *) x));
37561 }
37562 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37563 return (void *)((wxObject *) ((wxClipboard *) x));
37564 }
37565 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37566 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37567 }
37568 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37569 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37570 }
37571 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37572 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37573 }
37574 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37575 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37576 }
37577 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37578 return (void *)((wxObject *) ((wxToolTip *) x));
37579 }
37580 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37581 return (void *)((wxObject *) ((wxMenuItem *) x));
37582 }
37583 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37584 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37585 }
37586 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37587 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37588 }
37589 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37590 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37591 }
37592 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37593 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37594 }
37595 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37596 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37597 }
37598 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37599 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37600 }
37601 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37602 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37603 }
37604 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37605 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37606 }
37607 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37608 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37609 }
37610 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37611 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37612 }
37613 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37614 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37615 }
37616 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37617 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37618 }
37619 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37620 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37621 }
37622 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37623 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37624 }
37625 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37626 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37627 }
37628 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37629 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37630 }
37631 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37632 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37633 }
37634 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37635 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37636 }
37637 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37638 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37639 }
37640 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37641 return (void *)((wxObject *) ((wxImageHandler *) x));
37642 }
37643 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37644 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37645 }
37646 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37647 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37648 }
37649 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37650 return (void *)((wxObject *) ((wxEvtHandler *) x));
37651 }
37652 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37653 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37654 }
37655 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37656 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37657 }
37658 static void *_p_wxImageTo_p_wxObject(void *x) {
37659 return (void *)((wxObject *) ((wxImage *) x));
37660 }
37661 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37662 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37663 }
37664 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37665 return (void *)((wxObject *) ((wxSystemOptions *) x));
37666 }
37667 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37668 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37669 }
37670 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37671 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37672 }
37673 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37674 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37675 }
37676 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37677 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37678 }
37679 static void *_p_wxWindowTo_p_wxObject(void *x) {
37680 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37681 }
37682 static void *_p_wxMenuTo_p_wxObject(void *x) {
37683 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37684 }
37685 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37686 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37687 }
37688 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37689 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37690 }
37691 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37692 return (void *)((wxObject *) ((wxFileSystem *) x));
37693 }
37694 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37695 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37696 }
37697 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37698 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37699 }
37700 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37701 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37702 }
37703 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37704 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37705 }
37706 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37707 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37708 }
37709 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37710 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37711 }
37712 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37713 return (void *)((wxObject *) ((wxBusyInfo *) x));
37714 }
37715 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37716 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37717 }
37718 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37719 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37720 }
37721 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37722 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37723 }
37724 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37725 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37726 }
37727 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37728 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37729 }
37730 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37731 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37732 }
37733 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37734 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37735 }
37736 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37737 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37738 }
37739 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37740 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37741 }
37742 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37743 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37744 }
37745 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37746 return (void *)((wxLog *) ((wxLogBuffer *) x));
37747 }
37748 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37749 return (void *)((wxLog *) ((wxLogStderr *) x));
37750 }
37751 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37752 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37753 }
37754 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37755 return (void *)((wxLog *) ((wxLogWindow *) x));
37756 }
37757 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37758 return (void *)((wxLog *) ((wxLogChain *) x));
37759 }
37760 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37761 return (void *)((wxLog *) ((wxLogGui *) x));
37762 }
37763 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37764 return (void *)((wxLog *) ((wxPyLog *) x));
37765 }
37766 static void *_p_wxControlTo_p_wxWindow(void *x) {
37767 return (void *)((wxWindow *) ((wxControl *) x));
37768 }
37769 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37770 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37771 }
37772 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37773 return (void *)((wxWindow *) ((wxMenuBar *) x));
37774 }
37775 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37776 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37777 }
37778 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37779 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37780 }
37781 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37782 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};
37783 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37784 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37785 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37786 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37787 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37788 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37789 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37790 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37791 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37792 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37793 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37794 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37795 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37796 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37797 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37798 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37799 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37800 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37801 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37802 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37803 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37804 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37805 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37806 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37807 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37808 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37809 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37810 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37811 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37812 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37813 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37814 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37815 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37816 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37817 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37818 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37819 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37820 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37821 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37822 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37823 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37824 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37825 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37826 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37827 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37828 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37829 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37830 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37831 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37832 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37833 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37834 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37835 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37836 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37837 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37838 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37839 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37840 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37841 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37842 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37843 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37844 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37845 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37846 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37847 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37848 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37849 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37850 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37851 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37852 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37853 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37854 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37855 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37856 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37857 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37858 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37859 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37860 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37861 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37862 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37863 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37864 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37865 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37866 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37867 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37868 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37869 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37870 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37871 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37872 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37873 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37874 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37875 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37876 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37877 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37878 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37879 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37880 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37881 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37882 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37883 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37884 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37885 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37886 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37887 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37888 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37889 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37890 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37891 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37892 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37893 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37894 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37895 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37896 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37897 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37898 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37899 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37900 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37901 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37902 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37903 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37904 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37905 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37906 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37907 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37908 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37909 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37910 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37911 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37912 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37913 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37914 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37915 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37916 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37917 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37918 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37919 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37920 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37921 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37922 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37923 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37924 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37925 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37926 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37927 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37928 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37929 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37930 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37931 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37932 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37933 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37934 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37935 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37936 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37937 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37938 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37939 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37940 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37941 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37942 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37943 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37944 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37945 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37946 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37947 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37948 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37949 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37950 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37951 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37952
37953 static swig_type_info *swig_type_initial[] = {
37954 &_swigt__p_char,
37955 &_swigt__p_form_ops_t,
37956 &_swigt__p_int,
37957 &_swigt__p_unsigned_char,
37958 &_swigt__p_unsigned_int,
37959 &_swigt__p_unsigned_long,
37960 &_swigt__p_void,
37961 &_swigt__p_wxANIHandler,
37962 &_swigt__p_wxAcceleratorTable,
37963 &_swigt__p_wxActivateEvent,
37964 &_swigt__p_wxArrayString,
37965 &_swigt__p_wxBMPHandler,
37966 &_swigt__p_wxBitmap,
37967 &_swigt__p_wxBitmapDataObject,
37968 &_swigt__p_wxBoxSizer,
37969 &_swigt__p_wxBusyCursor,
37970 &_swigt__p_wxBusyInfo,
37971 &_swigt__p_wxCURHandler,
37972 &_swigt__p_wxCaret,
37973 &_swigt__p_wxChar,
37974 &_swigt__p_wxChildFocusEvent,
37975 &_swigt__p_wxClipboard,
37976 &_swigt__p_wxClipboardLocker,
37977 &_swigt__p_wxClipboardTextEvent,
37978 &_swigt__p_wxCloseEvent,
37979 &_swigt__p_wxColour,
37980 &_swigt__p_wxCommandEvent,
37981 &_swigt__p_wxConfig,
37982 &_swigt__p_wxConfigBase,
37983 &_swigt__p_wxConfigPathChanger,
37984 &_swigt__p_wxContextMenuEvent,
37985 &_swigt__p_wxControl,
37986 &_swigt__p_wxControlWithItems,
37987 &_swigt__p_wxCursor,
37988 &_swigt__p_wxCustomDataObject,
37989 &_swigt__p_wxDC,
37990 &_swigt__p_wxDataFormat,
37991 &_swigt__p_wxDataObject,
37992 &_swigt__p_wxDataObjectComposite,
37993 &_swigt__p_wxDataObjectSimple,
37994 &_swigt__p_wxDateEvent,
37995 &_swigt__p_wxDateSpan,
37996 &_swigt__p_wxDateTime,
37997 &_swigt__p_wxDateTime__TimeZone,
37998 &_swigt__p_wxDisplay,
37999 &_swigt__p_wxDisplayChangedEvent,
38000 &_swigt__p_wxDropFilesEvent,
38001 &_swigt__p_wxDuplexMode,
38002 &_swigt__p_wxEraseEvent,
38003 &_swigt__p_wxEvent,
38004 &_swigt__p_wxEvtHandler,
38005 &_swigt__p_wxFSFile,
38006 &_swigt__p_wxFileConfig,
38007 &_swigt__p_wxFileDataObject,
38008 &_swigt__p_wxFileHistory,
38009 &_swigt__p_wxFileSystem,
38010 &_swigt__p_wxFileType,
38011 &_swigt__p_wxFileTypeInfo,
38012 &_swigt__p_wxFlexGridSizer,
38013 &_swigt__p_wxFocusEvent,
38014 &_swigt__p_wxFont,
38015 &_swigt__p_wxFrame,
38016 &_swigt__p_wxGBSizerItem,
38017 &_swigt__p_wxGIFHandler,
38018 &_swigt__p_wxGridBagSizer,
38019 &_swigt__p_wxGridSizer,
38020 &_swigt__p_wxICOHandler,
38021 &_swigt__p_wxIcon,
38022 &_swigt__p_wxIconizeEvent,
38023 &_swigt__p_wxIdleEvent,
38024 &_swigt__p_wxImage,
38025 &_swigt__p_wxImageHandler,
38026 &_swigt__p_wxIndividualLayoutConstraint,
38027 &_swigt__p_wxInitDialogEvent,
38028 &_swigt__p_wxJPEGHandler,
38029 &_swigt__p_wxJoystick,
38030 &_swigt__p_wxJoystickEvent,
38031 &_swigt__p_wxKeyEvent,
38032 &_swigt__p_wxKillError,
38033 &_swigt__p_wxLayoutConstraints,
38034 &_swigt__p_wxLog,
38035 &_swigt__p_wxLogBuffer,
38036 &_swigt__p_wxLogChain,
38037 &_swigt__p_wxLogGui,
38038 &_swigt__p_wxLogNull,
38039 &_swigt__p_wxLogStderr,
38040 &_swigt__p_wxLogTextCtrl,
38041 &_swigt__p_wxLogWindow,
38042 &_swigt__p_wxMaximizeEvent,
38043 &_swigt__p_wxMenu,
38044 &_swigt__p_wxMenuBar,
38045 &_swigt__p_wxMenuEvent,
38046 &_swigt__p_wxMenuItem,
38047 &_swigt__p_wxMetafile,
38048 &_swigt__p_wxMetafileDataObject,
38049 &_swigt__p_wxMimeTypesManager,
38050 &_swigt__p_wxMouseCaptureChangedEvent,
38051 &_swigt__p_wxMouseEvent,
38052 &_swigt__p_wxMouseState,
38053 &_swigt__p_wxMoveEvent,
38054 &_swigt__p_wxMutexGuiLocker,
38055 &_swigt__p_wxNavigationKeyEvent,
38056 &_swigt__p_wxNcPaintEvent,
38057 &_swigt__p_wxNotifyEvent,
38058 &_swigt__p_wxObject,
38059 &_swigt__p_wxOutputStream,
38060 &_swigt__p_wxPCXHandler,
38061 &_swigt__p_wxPNGHandler,
38062 &_swigt__p_wxPNMHandler,
38063 &_swigt__p_wxPaintEvent,
38064 &_swigt__p_wxPaletteChangedEvent,
38065 &_swigt__p_wxPaperSize,
38066 &_swigt__p_wxPoint,
38067 &_swigt__p_wxPowerEvent,
38068 &_swigt__p_wxProcessEvent,
38069 &_swigt__p_wxPyApp,
38070 &_swigt__p_wxPyArtProvider,
38071 &_swigt__p_wxPyBitmapDataObject,
38072 &_swigt__p_wxPyCommandEvent,
38073 &_swigt__p_wxPyDataObjectSimple,
38074 &_swigt__p_wxPyDropSource,
38075 &_swigt__p_wxPyDropTarget,
38076 &_swigt__p_wxPyEvent,
38077 &_swigt__p_wxPyFileDropTarget,
38078 &_swigt__p_wxPyImageHandler,
38079 &_swigt__p_wxPyLog,
38080 &_swigt__p_wxPyProcess,
38081 &_swigt__p_wxPySizer,
38082 &_swigt__p_wxPyTextDataObject,
38083 &_swigt__p_wxPyTextDropTarget,
38084 &_swigt__p_wxPyTimer,
38085 &_swigt__p_wxPyTipProvider,
38086 &_swigt__p_wxPyValidator,
38087 &_swigt__p_wxQueryNewPaletteEvent,
38088 &_swigt__p_wxRect,
38089 &_swigt__p_wxScrollEvent,
38090 &_swigt__p_wxScrollWinEvent,
38091 &_swigt__p_wxSetCursorEvent,
38092 &_swigt__p_wxShowEvent,
38093 &_swigt__p_wxSingleInstanceChecker,
38094 &_swigt__p_wxSize,
38095 &_swigt__p_wxSizeEvent,
38096 &_swigt__p_wxSizer,
38097 &_swigt__p_wxSizerItem,
38098 &_swigt__p_wxSound,
38099 &_swigt__p_wxStandardPaths,
38100 &_swigt__p_wxStaticBoxSizer,
38101 &_swigt__p_wxStdDialogButtonSizer,
38102 &_swigt__p_wxStopWatch,
38103 &_swigt__p_wxString,
38104 &_swigt__p_wxSysColourChangedEvent,
38105 &_swigt__p_wxSystemOptions,
38106 &_swigt__p_wxSystemSettings,
38107 &_swigt__p_wxTIFFHandler,
38108 &_swigt__p_wxTextCtrl,
38109 &_swigt__p_wxTextDataObject,
38110 &_swigt__p_wxTimeSpan,
38111 &_swigt__p_wxTimer,
38112 &_swigt__p_wxTimerEvent,
38113 &_swigt__p_wxTimerRunner,
38114 &_swigt__p_wxTipProvider,
38115 &_swigt__p_wxToolTip,
38116 &_swigt__p_wxURLDataObject,
38117 &_swigt__p_wxUpdateUIEvent,
38118 &_swigt__p_wxValidator,
38119 &_swigt__p_wxVideoMode,
38120 &_swigt__p_wxWindow,
38121 &_swigt__p_wxWindowCreateEvent,
38122 &_swigt__p_wxWindowDestroyEvent,
38123 &_swigt__p_wxWindowDisabler,
38124 &_swigt__p_wxXPMHandler,
38125 };
38126
38127 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
38128 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
38129 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
38130 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
38131 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
38132 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
38133 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
38134 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
38135 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
38136 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}};
38137 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
38138 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
38139 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
38140 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
38141 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
38142 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
38143 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
38144 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
38145 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}};
38146 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
38147 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
38148 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
38149 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
38150 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
38151 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}};
38152 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
38153 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}};
38154 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
38155 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
38156 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
38157 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
38158 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
38159 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38160 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38161 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
38162 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
38163 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
38164 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
38165 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
38166 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
38167 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
38168 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
38169 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
38170 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
38171 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
38172 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38173 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38174 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
38175 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38176 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
38177 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
38178 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38179 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38180 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38181 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38182 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38183 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38184 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38185 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38186 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38187 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38188 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38189 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38190 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38191 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38192 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38193 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38194 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38195 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38196 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
38197 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38198 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38199 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38200 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38201 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38202 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38203 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}};
38204 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38205 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38206 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38207 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38208 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38209 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38210 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38211 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38212 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38213 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38214 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38215 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}};
38216 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38217 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38218 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38219 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38220 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38221 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38222 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38223 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38224 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
38225 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38226 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38227 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38228 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38229 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38230 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38231 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38232 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38233 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38234 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38235 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38236 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38237 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38238 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38239 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38240 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38241 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38242 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38243 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38244 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38245 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38246 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38247 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38248 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38249 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38250 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38251 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38252 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38253 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38254 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38255 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38256 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38257 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38258 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38259 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
38260 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38261 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38262 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38263 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38264 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38265 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38266 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38267 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38268 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38269 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}};
38270 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38271 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38272 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38273 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38274 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38275 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38276 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38277 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38278 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38279 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38280 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38281 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38282 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38283 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38284 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38285 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38286 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38287 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}};
38288 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38289 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38290 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38291 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38292 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}};
38293 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38294 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38295 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38296 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}};
38297 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38298
38299 static swig_cast_info *swig_cast_initial[] = {
38300 _swigc__p_char,
38301 _swigc__p_form_ops_t,
38302 _swigc__p_int,
38303 _swigc__p_unsigned_char,
38304 _swigc__p_unsigned_int,
38305 _swigc__p_unsigned_long,
38306 _swigc__p_void,
38307 _swigc__p_wxANIHandler,
38308 _swigc__p_wxAcceleratorTable,
38309 _swigc__p_wxActivateEvent,
38310 _swigc__p_wxArrayString,
38311 _swigc__p_wxBMPHandler,
38312 _swigc__p_wxBitmap,
38313 _swigc__p_wxBitmapDataObject,
38314 _swigc__p_wxBoxSizer,
38315 _swigc__p_wxBusyCursor,
38316 _swigc__p_wxBusyInfo,
38317 _swigc__p_wxCURHandler,
38318 _swigc__p_wxCaret,
38319 _swigc__p_wxChar,
38320 _swigc__p_wxChildFocusEvent,
38321 _swigc__p_wxClipboard,
38322 _swigc__p_wxClipboardLocker,
38323 _swigc__p_wxClipboardTextEvent,
38324 _swigc__p_wxCloseEvent,
38325 _swigc__p_wxColour,
38326 _swigc__p_wxCommandEvent,
38327 _swigc__p_wxConfig,
38328 _swigc__p_wxConfigBase,
38329 _swigc__p_wxConfigPathChanger,
38330 _swigc__p_wxContextMenuEvent,
38331 _swigc__p_wxControl,
38332 _swigc__p_wxControlWithItems,
38333 _swigc__p_wxCursor,
38334 _swigc__p_wxCustomDataObject,
38335 _swigc__p_wxDC,
38336 _swigc__p_wxDataFormat,
38337 _swigc__p_wxDataObject,
38338 _swigc__p_wxDataObjectComposite,
38339 _swigc__p_wxDataObjectSimple,
38340 _swigc__p_wxDateEvent,
38341 _swigc__p_wxDateSpan,
38342 _swigc__p_wxDateTime,
38343 _swigc__p_wxDateTime__TimeZone,
38344 _swigc__p_wxDisplay,
38345 _swigc__p_wxDisplayChangedEvent,
38346 _swigc__p_wxDropFilesEvent,
38347 _swigc__p_wxDuplexMode,
38348 _swigc__p_wxEraseEvent,
38349 _swigc__p_wxEvent,
38350 _swigc__p_wxEvtHandler,
38351 _swigc__p_wxFSFile,
38352 _swigc__p_wxFileConfig,
38353 _swigc__p_wxFileDataObject,
38354 _swigc__p_wxFileHistory,
38355 _swigc__p_wxFileSystem,
38356 _swigc__p_wxFileType,
38357 _swigc__p_wxFileTypeInfo,
38358 _swigc__p_wxFlexGridSizer,
38359 _swigc__p_wxFocusEvent,
38360 _swigc__p_wxFont,
38361 _swigc__p_wxFrame,
38362 _swigc__p_wxGBSizerItem,
38363 _swigc__p_wxGIFHandler,
38364 _swigc__p_wxGridBagSizer,
38365 _swigc__p_wxGridSizer,
38366 _swigc__p_wxICOHandler,
38367 _swigc__p_wxIcon,
38368 _swigc__p_wxIconizeEvent,
38369 _swigc__p_wxIdleEvent,
38370 _swigc__p_wxImage,
38371 _swigc__p_wxImageHandler,
38372 _swigc__p_wxIndividualLayoutConstraint,
38373 _swigc__p_wxInitDialogEvent,
38374 _swigc__p_wxJPEGHandler,
38375 _swigc__p_wxJoystick,
38376 _swigc__p_wxJoystickEvent,
38377 _swigc__p_wxKeyEvent,
38378 _swigc__p_wxKillError,
38379 _swigc__p_wxLayoutConstraints,
38380 _swigc__p_wxLog,
38381 _swigc__p_wxLogBuffer,
38382 _swigc__p_wxLogChain,
38383 _swigc__p_wxLogGui,
38384 _swigc__p_wxLogNull,
38385 _swigc__p_wxLogStderr,
38386 _swigc__p_wxLogTextCtrl,
38387 _swigc__p_wxLogWindow,
38388 _swigc__p_wxMaximizeEvent,
38389 _swigc__p_wxMenu,
38390 _swigc__p_wxMenuBar,
38391 _swigc__p_wxMenuEvent,
38392 _swigc__p_wxMenuItem,
38393 _swigc__p_wxMetafile,
38394 _swigc__p_wxMetafileDataObject,
38395 _swigc__p_wxMimeTypesManager,
38396 _swigc__p_wxMouseCaptureChangedEvent,
38397 _swigc__p_wxMouseEvent,
38398 _swigc__p_wxMouseState,
38399 _swigc__p_wxMoveEvent,
38400 _swigc__p_wxMutexGuiLocker,
38401 _swigc__p_wxNavigationKeyEvent,
38402 _swigc__p_wxNcPaintEvent,
38403 _swigc__p_wxNotifyEvent,
38404 _swigc__p_wxObject,
38405 _swigc__p_wxOutputStream,
38406 _swigc__p_wxPCXHandler,
38407 _swigc__p_wxPNGHandler,
38408 _swigc__p_wxPNMHandler,
38409 _swigc__p_wxPaintEvent,
38410 _swigc__p_wxPaletteChangedEvent,
38411 _swigc__p_wxPaperSize,
38412 _swigc__p_wxPoint,
38413 _swigc__p_wxPowerEvent,
38414 _swigc__p_wxProcessEvent,
38415 _swigc__p_wxPyApp,
38416 _swigc__p_wxPyArtProvider,
38417 _swigc__p_wxPyBitmapDataObject,
38418 _swigc__p_wxPyCommandEvent,
38419 _swigc__p_wxPyDataObjectSimple,
38420 _swigc__p_wxPyDropSource,
38421 _swigc__p_wxPyDropTarget,
38422 _swigc__p_wxPyEvent,
38423 _swigc__p_wxPyFileDropTarget,
38424 _swigc__p_wxPyImageHandler,
38425 _swigc__p_wxPyLog,
38426 _swigc__p_wxPyProcess,
38427 _swigc__p_wxPySizer,
38428 _swigc__p_wxPyTextDataObject,
38429 _swigc__p_wxPyTextDropTarget,
38430 _swigc__p_wxPyTimer,
38431 _swigc__p_wxPyTipProvider,
38432 _swigc__p_wxPyValidator,
38433 _swigc__p_wxQueryNewPaletteEvent,
38434 _swigc__p_wxRect,
38435 _swigc__p_wxScrollEvent,
38436 _swigc__p_wxScrollWinEvent,
38437 _swigc__p_wxSetCursorEvent,
38438 _swigc__p_wxShowEvent,
38439 _swigc__p_wxSingleInstanceChecker,
38440 _swigc__p_wxSize,
38441 _swigc__p_wxSizeEvent,
38442 _swigc__p_wxSizer,
38443 _swigc__p_wxSizerItem,
38444 _swigc__p_wxSound,
38445 _swigc__p_wxStandardPaths,
38446 _swigc__p_wxStaticBoxSizer,
38447 _swigc__p_wxStdDialogButtonSizer,
38448 _swigc__p_wxStopWatch,
38449 _swigc__p_wxString,
38450 _swigc__p_wxSysColourChangedEvent,
38451 _swigc__p_wxSystemOptions,
38452 _swigc__p_wxSystemSettings,
38453 _swigc__p_wxTIFFHandler,
38454 _swigc__p_wxTextCtrl,
38455 _swigc__p_wxTextDataObject,
38456 _swigc__p_wxTimeSpan,
38457 _swigc__p_wxTimer,
38458 _swigc__p_wxTimerEvent,
38459 _swigc__p_wxTimerRunner,
38460 _swigc__p_wxTipProvider,
38461 _swigc__p_wxToolTip,
38462 _swigc__p_wxURLDataObject,
38463 _swigc__p_wxUpdateUIEvent,
38464 _swigc__p_wxValidator,
38465 _swigc__p_wxVideoMode,
38466 _swigc__p_wxWindow,
38467 _swigc__p_wxWindowCreateEvent,
38468 _swigc__p_wxWindowDestroyEvent,
38469 _swigc__p_wxWindowDisabler,
38470 _swigc__p_wxXPMHandler,
38471 };
38472
38473
38474 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38475
38476 static swig_const_info swig_const_table[] = {
38477 {0, 0, 0, 0.0, 0, 0}};
38478
38479 #ifdef __cplusplus
38480 }
38481 #endif
38482 /* -----------------------------------------------------------------------------
38483 * Type initialization:
38484 * This problem is tough by the requirement that no dynamic
38485 * memory is used. Also, since swig_type_info structures store pointers to
38486 * swig_cast_info structures and swig_cast_info structures store pointers back
38487 * to swig_type_info structures, we need some lookup code at initialization.
38488 * The idea is that swig generates all the structures that are needed.
38489 * The runtime then collects these partially filled structures.
38490 * The SWIG_InitializeModule function takes these initial arrays out of
38491 * swig_module, and does all the lookup, filling in the swig_module.types
38492 * array with the correct data and linking the correct swig_cast_info
38493 * structures together.
38494 *
38495 * The generated swig_type_info structures are assigned staticly to an initial
38496 * array. We just loop though that array, and handle each type individually.
38497 * First we lookup if this type has been already loaded, and if so, use the
38498 * loaded structure instead of the generated one. Then we have to fill in the
38499 * cast linked list. The cast data is initially stored in something like a
38500 * two-dimensional array. Each row corresponds to a type (there are the same
38501 * number of rows as there are in the swig_type_initial array). Each entry in
38502 * a column is one of the swig_cast_info structures for that type.
38503 * The cast_initial array is actually an array of arrays, because each row has
38504 * a variable number of columns. So to actually build the cast linked list,
38505 * we find the array of casts associated with the type, and loop through it
38506 * adding the casts to the list. The one last trick we need to do is making
38507 * sure the type pointer in the swig_cast_info struct is correct.
38508 *
38509 * First off, we lookup the cast->type name to see if it is already loaded.
38510 * There are three cases to handle:
38511 * 1) If the cast->type has already been loaded AND the type we are adding
38512 * casting info to has not been loaded (it is in this module), THEN we
38513 * replace the cast->type pointer with the type pointer that has already
38514 * been loaded.
38515 * 2) If BOTH types (the one we are adding casting info to, and the
38516 * cast->type) are loaded, THEN the cast info has already been loaded by
38517 * the previous module so we just ignore it.
38518 * 3) Finally, if cast->type has not already been loaded, then we add that
38519 * swig_cast_info to the linked list (because the cast->type) pointer will
38520 * be correct.
38521 * ----------------------------------------------------------------------------- */
38522
38523 #ifdef __cplusplus
38524 extern "C" {
38525 #if 0
38526 } /* c-mode */
38527 #endif
38528 #endif
38529
38530 #if 0
38531 #define SWIGRUNTIME_DEBUG
38532 #endif
38533
38534 SWIGRUNTIME void
38535 SWIG_InitializeModule(void *clientdata) {
38536 size_t i;
38537 swig_module_info *module_head;
38538 static int init_run = 0;
38539
38540 clientdata = clientdata;
38541
38542 if (init_run) return;
38543 init_run = 1;
38544
38545 /* Initialize the swig_module */
38546 swig_module.type_initial = swig_type_initial;
38547 swig_module.cast_initial = swig_cast_initial;
38548
38549 /* Try and load any already created modules */
38550 module_head = SWIG_GetModule(clientdata);
38551 if (module_head) {
38552 swig_module.next = module_head->next;
38553 module_head->next = &swig_module;
38554 } else {
38555 /* This is the first module loaded */
38556 swig_module.next = &swig_module;
38557 SWIG_SetModule(clientdata, &swig_module);
38558 }
38559
38560 /* Now work on filling in swig_module.types */
38561 #ifdef SWIGRUNTIME_DEBUG
38562 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38563 #endif
38564 for (i = 0; i < swig_module.size; ++i) {
38565 swig_type_info *type = 0;
38566 swig_type_info *ret;
38567 swig_cast_info *cast;
38568
38569 #ifdef SWIGRUNTIME_DEBUG
38570 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38571 #endif
38572
38573 /* if there is another module already loaded */
38574 if (swig_module.next != &swig_module) {
38575 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38576 }
38577 if (type) {
38578 /* Overwrite clientdata field */
38579 #ifdef SWIGRUNTIME_DEBUG
38580 printf("SWIG_InitializeModule: found type %s\n", type->name);
38581 #endif
38582 if (swig_module.type_initial[i]->clientdata) {
38583 type->clientdata = swig_module.type_initial[i]->clientdata;
38584 #ifdef SWIGRUNTIME_DEBUG
38585 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38586 #endif
38587 }
38588 } else {
38589 type = swig_module.type_initial[i];
38590 }
38591
38592 /* Insert casting types */
38593 cast = swig_module.cast_initial[i];
38594 while (cast->type) {
38595 /* Don't need to add information already in the list */
38596 ret = 0;
38597 #ifdef SWIGRUNTIME_DEBUG
38598 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38599 #endif
38600 if (swig_module.next != &swig_module) {
38601 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38602 #ifdef SWIGRUNTIME_DEBUG
38603 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38604 #endif
38605 }
38606 if (ret) {
38607 if (type == swig_module.type_initial[i]) {
38608 #ifdef SWIGRUNTIME_DEBUG
38609 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38610 #endif
38611 cast->type = ret;
38612 ret = 0;
38613 } else {
38614 /* Check for casting already in the list */
38615 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38616 #ifdef SWIGRUNTIME_DEBUG
38617 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38618 #endif
38619 if (!ocast) ret = 0;
38620 }
38621 }
38622
38623 if (!ret) {
38624 #ifdef SWIGRUNTIME_DEBUG
38625 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38626 #endif
38627 if (type->cast) {
38628 type->cast->prev = cast;
38629 cast->next = type->cast;
38630 }
38631 type->cast = cast;
38632 }
38633 cast++;
38634 }
38635 /* Set entry in modules->types array equal to the type */
38636 swig_module.types[i] = type;
38637 }
38638 swig_module.types[i] = 0;
38639
38640 #ifdef SWIGRUNTIME_DEBUG
38641 printf("**** SWIG_InitializeModule: Cast List ******\n");
38642 for (i = 0; i < swig_module.size; ++i) {
38643 int j = 0;
38644 swig_cast_info *cast = swig_module.cast_initial[i];
38645 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38646 while (cast->type) {
38647 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38648 cast++;
38649 ++j;
38650 }
38651 printf("---- Total casts: %d\n",j);
38652 }
38653 printf("**** SWIG_InitializeModule: Cast List ******\n");
38654 #endif
38655 }
38656
38657 /* This function will propagate the clientdata field of type to
38658 * any new swig_type_info structures that have been added into the list
38659 * of equivalent types. It is like calling
38660 * SWIG_TypeClientData(type, clientdata) a second time.
38661 */
38662 SWIGRUNTIME void
38663 SWIG_PropagateClientData(void) {
38664 size_t i;
38665 swig_cast_info *equiv;
38666 static int init_run = 0;
38667
38668 if (init_run) return;
38669 init_run = 1;
38670
38671 for (i = 0; i < swig_module.size; i++) {
38672 if (swig_module.types[i]->clientdata) {
38673 equiv = swig_module.types[i]->cast;
38674 while (equiv) {
38675 if (!equiv->converter) {
38676 if (equiv->type && !equiv->type->clientdata)
38677 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38678 }
38679 equiv = equiv->next;
38680 }
38681 }
38682 }
38683 }
38684
38685 #ifdef __cplusplus
38686 #if 0
38687 {
38688 /* c-mode */
38689 #endif
38690 }
38691 #endif
38692
38693
38694
38695 #ifdef __cplusplus
38696 extern "C" {
38697 #endif
38698
38699 /* Python-specific SWIG API */
38700 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38701 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38702 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38703
38704 /* -----------------------------------------------------------------------------
38705 * global variable support code.
38706 * ----------------------------------------------------------------------------- */
38707
38708 typedef struct swig_globalvar {
38709 char *name; /* Name of global variable */
38710 PyObject *(*get_attr)(void); /* Return the current value */
38711 int (*set_attr)(PyObject *); /* Set the value */
38712 struct swig_globalvar *next;
38713 } swig_globalvar;
38714
38715 typedef struct swig_varlinkobject {
38716 PyObject_HEAD
38717 swig_globalvar *vars;
38718 } swig_varlinkobject;
38719
38720 SWIGINTERN PyObject *
38721 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38722 return PyString_FromString("<Swig global variables>");
38723 }
38724
38725 SWIGINTERN PyObject *
38726 swig_varlink_str(swig_varlinkobject *v) {
38727 PyObject *str = PyString_FromString("(");
38728 swig_globalvar *var;
38729 for (var = v->vars; var; var=var->next) {
38730 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38731 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38732 }
38733 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38734 return str;
38735 }
38736
38737 SWIGINTERN int
38738 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38739 PyObject *str = swig_varlink_str(v);
38740 fprintf(fp,"Swig global variables ");
38741 fprintf(fp,"%s\n", PyString_AsString(str));
38742 Py_DECREF(str);
38743 return 0;
38744 }
38745
38746 SWIGINTERN void
38747 swig_varlink_dealloc(swig_varlinkobject *v) {
38748 swig_globalvar *var = v->vars;
38749 while (var) {
38750 swig_globalvar *n = var->next;
38751 free(var->name);
38752 free(var);
38753 var = n;
38754 }
38755 }
38756
38757 SWIGINTERN PyObject *
38758 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38759 PyObject *res = NULL;
38760 swig_globalvar *var = v->vars;
38761 while (var) {
38762 if (strcmp(var->name,n) == 0) {
38763 res = (*var->get_attr)();
38764 break;
38765 }
38766 var = var->next;
38767 }
38768 if (res == NULL && !PyErr_Occurred()) {
38769 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38770 }
38771 return res;
38772 }
38773
38774 SWIGINTERN int
38775 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38776 int res = 1;
38777 swig_globalvar *var = v->vars;
38778 while (var) {
38779 if (strcmp(var->name,n) == 0) {
38780 res = (*var->set_attr)(p);
38781 break;
38782 }
38783 var = var->next;
38784 }
38785 if (res == 1 && !PyErr_Occurred()) {
38786 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38787 }
38788 return res;
38789 }
38790
38791 SWIGINTERN PyTypeObject*
38792 swig_varlink_type(void) {
38793 static char varlink__doc__[] = "Swig var link object";
38794 static PyTypeObject varlink_type;
38795 static int type_init = 0;
38796 if (!type_init) {
38797 const PyTypeObject tmp
38798 = {
38799 PyObject_HEAD_INIT(NULL)
38800 0, /* Number of items in variable part (ob_size) */
38801 (char *)"swigvarlink", /* Type name (tp_name) */
38802 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38803 0, /* Itemsize (tp_itemsize) */
38804 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38805 (printfunc) swig_varlink_print, /* Print (tp_print) */
38806 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38807 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38808 0, /* tp_compare */
38809 (reprfunc) swig_varlink_repr, /* tp_repr */
38810 0, /* tp_as_number */
38811 0, /* tp_as_sequence */
38812 0, /* tp_as_mapping */
38813 0, /* tp_hash */
38814 0, /* tp_call */
38815 (reprfunc)swig_varlink_str, /* tp_str */
38816 0, /* tp_getattro */
38817 0, /* tp_setattro */
38818 0, /* tp_as_buffer */
38819 0, /* tp_flags */
38820 varlink__doc__, /* tp_doc */
38821 0, /* tp_traverse */
38822 0, /* tp_clear */
38823 0, /* tp_richcompare */
38824 0, /* tp_weaklistoffset */
38825 #if PY_VERSION_HEX >= 0x02020000
38826 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38827 #endif
38828 #if PY_VERSION_HEX >= 0x02030000
38829 0, /* tp_del */
38830 #endif
38831 #ifdef COUNT_ALLOCS
38832 0,0,0,0 /* tp_alloc -> tp_next */
38833 #endif
38834 };
38835 varlink_type = tmp;
38836 varlink_type.ob_type = &PyType_Type;
38837 type_init = 1;
38838 }
38839 return &varlink_type;
38840 }
38841
38842 /* Create a variable linking object for use later */
38843 SWIGINTERN PyObject *
38844 SWIG_Python_newvarlink(void) {
38845 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38846 if (result) {
38847 result->vars = 0;
38848 }
38849 return ((PyObject*) result);
38850 }
38851
38852 SWIGINTERN void
38853 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38854 swig_varlinkobject *v = (swig_varlinkobject *) p;
38855 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38856 if (gv) {
38857 size_t size = strlen(name)+1;
38858 gv->name = (char *)malloc(size);
38859 if (gv->name) {
38860 strncpy(gv->name,name,size);
38861 gv->get_attr = get_attr;
38862 gv->set_attr = set_attr;
38863 gv->next = v->vars;
38864 }
38865 }
38866 v->vars = gv;
38867 }
38868
38869 SWIGINTERN PyObject *
38870 SWIG_globals() {
38871 static PyObject *_SWIG_globals = 0;
38872 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38873 return _SWIG_globals;
38874 }
38875
38876 /* -----------------------------------------------------------------------------
38877 * constants/methods manipulation
38878 * ----------------------------------------------------------------------------- */
38879
38880 /* Install Constants */
38881 SWIGINTERN void
38882 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38883 PyObject *obj = 0;
38884 size_t i;
38885 for (i = 0; constants[i].type; ++i) {
38886 switch(constants[i].type) {
38887 case SWIG_PY_POINTER:
38888 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38889 break;
38890 case SWIG_PY_BINARY:
38891 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38892 break;
38893 default:
38894 obj = 0;
38895 break;
38896 }
38897 if (obj) {
38898 PyDict_SetItemString(d, constants[i].name, obj);
38899 Py_DECREF(obj);
38900 }
38901 }
38902 }
38903
38904 /* -----------------------------------------------------------------------------*/
38905 /* Fix SwigMethods to carry the callback ptrs when needed */
38906 /* -----------------------------------------------------------------------------*/
38907
38908 SWIGINTERN void
38909 SWIG_Python_FixMethods(PyMethodDef *methods,
38910 swig_const_info *const_table,
38911 swig_type_info **types,
38912 swig_type_info **types_initial) {
38913 size_t i;
38914 for (i = 0; methods[i].ml_name; ++i) {
38915 const char *c = methods[i].ml_doc;
38916 if (c && (c = strstr(c, "swig_ptr: "))) {
38917 int j;
38918 swig_const_info *ci = 0;
38919 const char *name = c + 10;
38920 for (j = 0; const_table[j].type; ++j) {
38921 if (strncmp(const_table[j].name, name,
38922 strlen(const_table[j].name)) == 0) {
38923 ci = &(const_table[j]);
38924 break;
38925 }
38926 }
38927 if (ci) {
38928 size_t shift = (ci->ptype) - types;
38929 swig_type_info *ty = types_initial[shift];
38930 size_t ldoc = (c - methods[i].ml_doc);
38931 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38932 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38933 if (ndoc) {
38934 char *buff = ndoc;
38935 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38936 if (ptr) {
38937 strncpy(buff, methods[i].ml_doc, ldoc);
38938 buff += ldoc;
38939 strncpy(buff, "swig_ptr: ", 10);
38940 buff += 10;
38941 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38942 methods[i].ml_doc = ndoc;
38943 }
38944 }
38945 }
38946 }
38947 }
38948 }
38949
38950 #ifdef __cplusplus
38951 }
38952 #endif
38953
38954 /* -----------------------------------------------------------------------------*
38955 * Partial Init method
38956 * -----------------------------------------------------------------------------*/
38957
38958 #ifdef __cplusplus
38959 extern "C"
38960 #endif
38961 SWIGEXPORT void SWIG_init(void) {
38962 PyObject *m, *d;
38963
38964 /* Fix SwigMethods to carry the callback ptrs when needed */
38965 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38966
38967 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38968 d = PyModule_GetDict(m);
38969
38970 SWIG_InitializeModule(0);
38971 SWIG_InstallConstants(d,swig_const_table);
38972
38973
38974 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38975 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38976 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38977 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38978 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38979 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38980 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38981 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38982 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38983 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38984 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38985 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38986 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38987 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38988 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38989 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38990 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38991 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38992 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38993 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38994 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38995 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38996 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38997 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38998 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38999 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
39000 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
39001 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
39002 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
39003 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
39004 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
39005 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
39006 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
39007 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
39008 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
39009 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
39010 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
39011 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
39012 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
39013 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
39014 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
39015 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
39016 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
39017 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
39018 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
39019 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
39020 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
39021 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
39022 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
39023 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
39024 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
39025 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
39026 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
39027 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
39028 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
39029 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
39030 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
39031 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
39032 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
39033 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
39034 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
39035 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
39036 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
39037 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
39038 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
39039 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
39040 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
39041 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
39042 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
39043 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
39044 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
39045 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
39046 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
39047 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
39048 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
39049 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
39050 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
39051 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
39052 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
39053 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
39054 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
39055 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
39056 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
39057 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
39058 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
39059 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
39060 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
39061 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
39062 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
39063 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
39064 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
39065 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
39066 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
39067 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
39068 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
39069 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
39070 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
39071 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
39072 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
39073 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
39074 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
39075 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
39076 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
39077 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
39078 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
39079 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
39080 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
39081 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
39082 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
39083 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
39084 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
39085 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
39086 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
39087 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
39088 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
39089 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
39090 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
39091 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
39092 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
39093 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
39094 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
39095 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
39096 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
39097 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
39098 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
39099 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
39100 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
39101 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
39102 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
39103 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
39104 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
39105 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
39106 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
39107 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
39108 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
39109 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
39110 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
39111
39112 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
39113
39114 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
39115 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
39116 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
39117 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
39118 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
39119 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
39120 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
39121 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
39122 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
39123 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
39124 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
39125 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
39126 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
39127 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
39128 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
39129 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
39130 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
39131 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
39132 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
39133 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
39134 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
39135 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
39136 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
39137 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
39138 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
39139 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
39140 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
39141 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
39142 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
39143 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
39144 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
39145 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
39146 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
39147 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
39148 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
39149 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
39150 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
39151 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
39152 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
39153 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
39154 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
39155 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
39156 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
39157 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
39158 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
39159 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
39160 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
39161 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
39162 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
39163 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
39164 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
39165 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
39166 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
39167
39168 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
39169
39170 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
39171 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
39172 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
39173 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
39174 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
39175 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
39176 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
39177 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
39178 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
39179 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
39180 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
39181 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
39182 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
39183 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
39184 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
39185 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
39186 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
39187 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
39188 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
39189 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
39190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
39191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
39192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
39193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
39194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
39195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
39196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
39197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
39198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
39199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
39200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
39201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
39202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
39203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
39204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39211 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39212 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39213 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39214 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39215 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39216 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39217 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39218 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39219 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39220 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39221 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39222 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39223 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39224 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39225 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39226 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39227 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39240 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39241 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39242 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39243 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39244 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39245 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39246
39247 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39248
39249 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39250 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39251 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39252 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39253 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39254 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39255 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39256 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39257 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39258 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39259 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39260 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39261 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39262 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39263 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39264 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39265 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39266 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39267 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39268 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39269 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39270 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39271 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39272 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39273 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39274 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39275 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39276 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39277 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39278 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39279 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39280 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39281 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39282 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39283 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39284 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39285 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39286 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39287 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39288 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39289 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39290 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39291 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39292 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39293 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39294 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39295 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39296 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39297 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39298 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39299 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39300 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39301 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39302 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39303 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39304 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39305 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39306 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39307 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39308 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39309 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39310 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39311 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39312 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39313 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39314 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39315 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39316 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39317 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39318 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39319 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39320 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39321 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39322 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39323 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39324 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39325 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39326 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39327 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39328 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39329 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39330 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39331 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39332 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39333 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39334 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39335 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39336 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39337 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39338 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39339 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39340 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39341 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39342 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39343 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39344 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39345 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39346 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39347 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39348 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39349 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39350 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39351 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39352 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39353 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39354 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39355 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39356 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39357 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39358 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39359 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39360 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39361 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39362 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39363 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39364 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39365 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39366 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39367 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39368 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39369 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39370 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39371 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39372 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39373 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39374 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39375 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39376 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39377 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39378 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39379 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39380 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39381 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39382 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39383 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39384 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39385 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39386 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39387 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39388 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39389 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39390 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39391 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39392 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39393 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39394 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39395 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39396 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39397 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39398 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39399 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39400 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39401 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39402 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39403 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39404 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39405 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39406 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39407 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39408 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39409 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39410 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39411 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39412 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39413 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39414 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39415 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39416 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39417 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39418 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39419 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39420 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39421 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39422 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39423 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39424 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39425 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39426 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39427 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39428 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39429 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39430 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39431 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39432 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39433 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39434 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39435 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39436 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39437 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39438 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39439 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39440 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39441 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39442 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39443 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39444 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39445 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39446 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39447 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39448 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39449
39450 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39451 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39452 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39453 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39454
39455 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39456 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39457 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39458 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39459 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39460 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39461 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39462 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39463 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39464 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39465 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39466 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39467 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39468 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39469 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39470 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39471 }
39472
wxWidgets (Impactor)