projects / wxWidgets.git / blob
? search:


d051c3d59e014dbb2f142bd4a23b1f5b52205cba
[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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_unsigned_char swig_types[3]
2466 #define SWIGTYPE_p_unsigned_int swig_types[4]
2467 #define SWIGTYPE_p_unsigned_long swig_types[5]
2468 #define SWIGTYPE_p_void swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBitmap swig_types[12]
2475 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2476 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2477 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2478 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2480 #define SWIGTYPE_p_wxCaret swig_types[18]
2481 #define SWIGTYPE_p_wxChar swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboard swig_types[21]
2484 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2485 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2486 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2487 #define SWIGTYPE_p_wxColour swig_types[25]
2488 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2489 #define SWIGTYPE_p_wxConfig swig_types[27]
2490 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2491 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2492 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2493 #define SWIGTYPE_p_wxControl swig_types[31]
2494 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2495 #define SWIGTYPE_p_wxCursor swig_types[33]
2496 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2497 #define SWIGTYPE_p_wxDC swig_types[35]
2498 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2499 #define SWIGTYPE_p_wxDataObject swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2501 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2502 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2503 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime swig_types[42]
2505 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2506 #define SWIGTYPE_p_wxDisplay swig_types[44]
2507 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2509 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2510 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvent swig_types[49]
2512 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2513 #define SWIGTYPE_p_wxFSFile swig_types[51]
2514 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2515 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2516 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2517 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2518 #define SWIGTYPE_p_wxFileType swig_types[56]
2519 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2520 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2521 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2522 #define SWIGTYPE_p_wxFont swig_types[60]
2523 #define SWIGTYPE_p_wxFrame swig_types[61]
2524 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2525 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2526 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2527 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2528 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2529 #define SWIGTYPE_p_wxIcon swig_types[67]
2530 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2532 #define SWIGTYPE_p_wxImage swig_types[70]
2533 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2534 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2535 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2536 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2537 #define SWIGTYPE_p_wxJoystick swig_types[75]
2538 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2540 #define SWIGTYPE_p_wxKillError swig_types[78]
2541 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2542 #define SWIGTYPE_p_wxLog swig_types[80]
2543 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2544 #define SWIGTYPE_p_wxLogChain swig_types[82]
2545 #define SWIGTYPE_p_wxLogGui swig_types[83]
2546 #define SWIGTYPE_p_wxLogNull swig_types[84]
2547 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2548 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2549 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2550 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2551 #define SWIGTYPE_p_wxMemorySize swig_types[89]
2552 #define SWIGTYPE_p_wxMenu swig_types[90]
2553 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2554 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2555 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2556 #define SWIGTYPE_p_wxMetafile swig_types[94]
2557 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2558 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2559 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2560 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2561 #define SWIGTYPE_p_wxMouseState swig_types[99]
2562 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2563 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2564 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2566 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2567 #define SWIGTYPE_p_wxObject swig_types[105]
2568 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2569 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2572 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2573 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2574 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2575 #define SWIGTYPE_p_wxPoint swig_types[113]
2576 #define SWIGTYPE_p_wxProcessEvent swig_types[114]
2577 #define SWIGTYPE_p_wxPyApp swig_types[115]
2578 #define SWIGTYPE_p_wxPyArtProvider swig_types[116]
2579 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[117]
2580 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
2581 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[119]
2582 #define SWIGTYPE_p_wxPyDropSource swig_types[120]
2583 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
2584 #define SWIGTYPE_p_wxPyEvent swig_types[122]
2585 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[123]
2586 #define SWIGTYPE_p_wxPyImageHandler swig_types[124]
2587 #define SWIGTYPE_p_wxPyLog swig_types[125]
2588 #define SWIGTYPE_p_wxPyProcess swig_types[126]
2589 #define SWIGTYPE_p_wxPySizer swig_types[127]
2590 #define SWIGTYPE_p_wxPyTextDataObject swig_types[128]
2591 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[129]
2592 #define SWIGTYPE_p_wxPyTimer swig_types[130]
2593 #define SWIGTYPE_p_wxPyTipProvider swig_types[131]
2594 #define SWIGTYPE_p_wxPyValidator swig_types[132]
2595 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[133]
2596 #define SWIGTYPE_p_wxRect swig_types[134]
2597 #define SWIGTYPE_p_wxScrollEvent swig_types[135]
2598 #define SWIGTYPE_p_wxScrollWinEvent swig_types[136]
2599 #define SWIGTYPE_p_wxSetCursorEvent swig_types[137]
2600 #define SWIGTYPE_p_wxShowEvent swig_types[138]
2601 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[139]
2602 #define SWIGTYPE_p_wxSize swig_types[140]
2603 #define SWIGTYPE_p_wxSizeEvent swig_types[141]
2604 #define SWIGTYPE_p_wxSizer swig_types[142]
2605 #define SWIGTYPE_p_wxSizerItem swig_types[143]
2606 #define SWIGTYPE_p_wxSound swig_types[144]
2607 #define SWIGTYPE_p_wxStandardPaths swig_types[145]
2608 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[146]
2609 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[147]
2610 #define SWIGTYPE_p_wxStopWatch swig_types[148]
2611 #define SWIGTYPE_p_wxString swig_types[149]
2612 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[150]
2613 #define SWIGTYPE_p_wxSystemOptions swig_types[151]
2614 #define SWIGTYPE_p_wxSystemSettings swig_types[152]
2615 #define SWIGTYPE_p_wxTIFFHandler swig_types[153]
2616 #define SWIGTYPE_p_wxTextCtrl swig_types[154]
2617 #define SWIGTYPE_p_wxTextDataObject swig_types[155]
2618 #define SWIGTYPE_p_wxTimeSpan swig_types[156]
2619 #define SWIGTYPE_p_wxTimer swig_types[157]
2620 #define SWIGTYPE_p_wxTimerEvent swig_types[158]
2621 #define SWIGTYPE_p_wxTimerRunner swig_types[159]
2622 #define SWIGTYPE_p_wxTipProvider swig_types[160]
2623 #define SWIGTYPE_p_wxToolTip swig_types[161]
2624 #define SWIGTYPE_p_wxURLDataObject swig_types[162]
2625 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[163]
2626 #define SWIGTYPE_p_wxValidator swig_types[164]
2627 #define SWIGTYPE_p_wxVideoMode swig_types[165]
2628 #define SWIGTYPE_p_wxWindow swig_types[166]
2629 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[167]
2630 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[168]
2631 #define SWIGTYPE_p_wxWindowDisabler swig_types[169]
2632 #define SWIGTYPE_p_wxXPMHandler swig_types[170]
2633 static swig_type_info *swig_types[172];
2634 static swig_module_info swig_module = {swig_types, 171, 0, 0, 0, 0};
2635 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2636 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2637
2638 /* -------- TYPES TABLE (END) -------- */
2639
2640 #if (PY_VERSION_HEX <= 0x02000000)
2641 # if !defined(SWIG_PYTHON_CLASSIC)
2642 # error "This python version requires to use swig with the '-classic' option"
2643 # endif
2644 #endif
2645 #if (PY_VERSION_HEX <= 0x02020000)
2646 # error "This python version requires to use swig with the '-nomodern' option"
2647 #endif
2648 #if (PY_VERSION_HEX <= 0x02020000)
2649 # error "This python version requires to use swig with the '-nomodernargs' option"
2650 #endif
2651 #ifndef METH_O
2652 # error "This python version requires to use swig with the '-nofastunpack' option"
2653 #endif
2654
2655 /*-----------------------------------------------
2656 @(target):= _misc_.so
2657 ------------------------------------------------*/
2658 #define SWIG_init init_misc_
2659
2660 #define SWIG_name "_misc_"
2661
2662 #define SWIGVERSION 0x010329
2663
2664
2665 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2666 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2667
2668
2669 #include <stdexcept>
2670
2671
2672 namespace swig {
2673 class PyObject_ptr {
2674 protected:
2675 PyObject *_obj;
2676
2677 public:
2678 PyObject_ptr() :_obj(0)
2679 {
2680 }
2681
2682 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2683 {
2684 Py_XINCREF(_obj);
2685 }
2686
2687 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2688 {
2689 if (initial_ref) Py_XINCREF(_obj);
2690 }
2691
2692 PyObject_ptr & operator=(const PyObject_ptr& item)
2693 {
2694 Py_XINCREF(item._obj);
2695 Py_XDECREF(_obj);
2696 _obj = item._obj;
2697 return *this;
2698 }
2699
2700 ~PyObject_ptr()
2701 {
2702 Py_XDECREF(_obj);
2703 }
2704
2705 operator PyObject *() const
2706 {
2707 return _obj;
2708 }
2709
2710 PyObject *operator->() const
2711 {
2712 return _obj;
2713 }
2714 };
2715 }
2716
2717
2718 namespace swig {
2719 struct PyObject_var : PyObject_ptr {
2720 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2721
2722 PyObject_var & operator = (PyObject* obj)
2723 {
2724 Py_XDECREF(_obj);
2725 _obj = obj;
2726 return *this;
2727 }
2728 };
2729 }
2730
2731
2732 #include "wx/wxPython/wxPython.h"
2733 #include "wx/wxPython/pyclasses.h"
2734 #include "wx/wxPython/pyistream.h"
2735
2736 static const wxString wxPyEmptyString(wxEmptyString);
2737
2738
2739
2740 #define SWIG_From_long PyInt_FromLong
2741
2742
2743 SWIGINTERNINLINE PyObject *
2744 SWIG_From_int (int value)
2745 {
2746 return SWIG_From_long (value);
2747 }
2748
2749
2750 #include <limits.h>
2751 #ifndef LLONG_MIN
2752 # define LLONG_MIN LONG_LONG_MIN
2753 #endif
2754 #ifndef LLONG_MAX
2755 # define LLONG_MAX LONG_LONG_MAX
2756 #endif
2757 #ifndef ULLONG_MAX
2758 # define ULLONG_MAX ULONG_LONG_MAX
2759 #endif
2760
2761
2762 SWIGINTERN int
2763 SWIG_AsVal_long (PyObject* obj, long* val)
2764 {
2765 if (PyNumber_Check(obj)) {
2766 if (val) *val = PyInt_AsLong(obj);
2767 return SWIG_OK;
2768 }
2769 return SWIG_TypeError;
2770 }
2771
2772
2773 SWIGINTERN int
2774 SWIG_AsVal_int (PyObject * obj, int *val)
2775 {
2776 long v;
2777 int res = SWIG_AsVal_long (obj, &v);
2778 if (SWIG_IsOK(res)) {
2779 if ((v < INT_MIN || v > INT_MAX)) {
2780 return SWIG_OverflowError;
2781 } else {
2782 if (val) *val = static_cast< int >(v);
2783 }
2784 }
2785 return res;
2786 }
2787
2788 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2789
2790 #include <wx/stockitem.h>
2791
2792 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2793 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2794 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2795
2796 SWIGINTERN int
2797 SWIG_AsVal_bool (PyObject *obj, bool *val)
2798 {
2799 if (obj == Py_True) {
2800 if (val) *val = true;
2801 return SWIG_OK;
2802 } else if (obj == Py_False) {
2803 if (val) *val = false;
2804 return SWIG_OK;
2805 } else {
2806 long v = 0;
2807 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2808 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2809 return res;
2810 }
2811 }
2812
2813
2814 SWIGINTERN int
2815 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2816 {
2817 long v = 0;
2818 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2819 return SWIG_TypeError;
2820 }
2821 else if (val)
2822 *val = (unsigned long)v;
2823 return SWIG_OK;
2824 }
2825
2826
2827 SWIGINTERNINLINE PyObject*
2828 SWIG_From_unsigned_SS_long (unsigned long value)
2829 {
2830 return (value > LONG_MAX) ?
2831 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2832 }
2833
2834
2835 void* wxGetXDisplay()
2836 {
2837 #ifdef __WXGTK__
2838 return wxGetDisplay();
2839 #else
2840 return NULL;
2841 #endif
2842 }
2843
2844
2845 wxWindow* FindWindowAtPointer() {
2846 wxPoint unused;
2847 return wxFindWindowAtPointer(unused);
2848 }
2849
2850
2851 bool wxThread_IsMain() {
2852 #ifdef WXP_WITH_THREAD
2853 return wxThread::IsMain();
2854 #else
2855 return true;
2856 #endif
2857 }
2858
2859 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2860 delete self;
2861 }
2862
2863 #include <wx/snglinst.h>
2864
2865
2866 #ifdef __WXMSW__
2867 #include <wx/msw/private.h>
2868 #include <wx/dynload.h>
2869 #endif
2870
2871
2872
2873 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2874 #if 0
2875 , int method
2876 #endif
2877 )
2878 {
2879 #ifdef __WXMSW__
2880 #if 0
2881 switch (method)
2882 {
2883 case 1:
2884 // This one only partially works. Appears to be an undocumented
2885 // "standard" convention that not all widgets adhear to. For
2886 // example, for some widgets backgrounds or non-client areas may
2887 // not be painted.
2888 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2889 break;
2890
2891 case 2:
2892 #endif
2893 // This one works much better, nearly all widgets and their
2894 // children are captured correctly[**]. Prior to the big
2895 // background erase changes that Vadim did in 2004-2005 this
2896 // method failed badly on XP with Themes activated, most native
2897 // widgets draw only partially, if at all. Without themes it
2898 // worked just like on Win2k. After those changes this method
2899 // works very well.
2900 //
2901 // ** For example the radio buttons in a wxRadioBox are not its
2902 // children by default, but you can capture it via the panel
2903 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2904 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2905 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2906 PRF_ERASEBKGND | PRF_OWNED );
2907 return true;
2908 #if 0
2909 break;
2910
2911 case 3:
2912 // This one is only defined in the latest SDK and is only
2913 // available on XP. MSDN says it is similar to sending WM_PRINT
2914 // so I expect that it will work similar to the above. Since it
2915 // is avaialble only on XP, it can't be compiled like this and
2916 // will have to be loaded dynamically.
2917 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2918
2919 // fall through
2920
2921 case 4:
2922 // Use PrintWindow if available, or fallback to WM_PRINT
2923 // otherwise. Unfortunately using PrintWindow is even worse than
2924 // WM_PRINT. For most native widgets nothing is drawn to the dc
2925 // at all, with or without Themes.
2926 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2927 static bool s_triedToLoad = false;
2928 static PrintWindow_t pfnPrintWindow = NULL;
2929 if ( !s_triedToLoad )
2930 {
2931
2932 s_triedToLoad = true;
2933 wxDynamicLibrary dllUser32(_T("user32.dll"));
2934 if ( dllUser32.IsLoaded() )
2935 {
2936 wxLogNull nolog; // Don't report errors here
2937 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2938 }
2939 }
2940 if (pfnPrintWindow)
2941 {
2942 //printf("Using PrintWindow\n");
2943 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2944 }
2945 else
2946 {
2947 //printf("Using WM_PRINT\n");
2948 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2949 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2950 PRF_ERASEBKGND | PRF_OWNED );
2951 }
2952 }
2953 #endif // 0
2954 #else
2955 return false;
2956 #endif // __WXMSW__
2957 }
2958
2959
2960
2961 #include <wx/tipdlg.h>
2962
2963
2964 SWIGINTERNINLINE PyObject *
2965 SWIG_From_size_t (size_t value)
2966 {
2967 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2968 }
2969
2970
2971 class wxPyTipProvider : public wxTipProvider {
2972 public:
2973 wxPyTipProvider(size_t currentTip)
2974 : wxTipProvider(currentTip) {}
2975
2976 DEC_PYCALLBACK_STRING__pure(GetTip);
2977 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2978 PYPRIVATE;
2979 };
2980
2981 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2982 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2983
2984
2985 SWIGINTERNINLINE int
2986 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2987 {
2988 unsigned long v;
2989 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2990 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2991 return res;
2992 }
2993
2994
2995 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
2996
2997 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
2998
2999 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3000 : wxTimer(owner, id)
3001 {
3002 if (owner == NULL)
3003 SetOwner(this);
3004 }
3005
3006
3007 SWIGINTERN swig_type_info*
3008 SWIG_pchar_descriptor()
3009 {
3010 static int init = 0;
3011 static swig_type_info* info = 0;
3012 if (!init) {
3013 info = SWIG_TypeQuery("_p_char");
3014 init = 1;
3015 }
3016 return info;
3017 }
3018
3019
3020 SWIGINTERNINLINE PyObject *
3021 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3022 {
3023 if (carray) {
3024 if (size > INT_MAX) {
3025 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3026 return pchar_descriptor ?
3027 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3028 } else {
3029 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3030 }
3031 } else {
3032 return SWIG_Py_Void();
3033 }
3034 }
3035
3036
3037 SWIGINTERNINLINE PyObject *
3038 SWIG_FromCharPtr(const char *cptr)
3039 {
3040 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3041 }
3042
3043
3044 SWIGINTERN int
3045 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3046 {
3047 unsigned long v;
3048 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3049 if (SWIG_IsOK(res)) {
3050 if ((v > UINT_MAX)) {
3051 return SWIG_OverflowError;
3052 } else {
3053 if (val) *val = static_cast< unsigned int >(v);
3054 }
3055 }
3056 return res;
3057 }
3058
3059 SWIGINTERN wxString wxLog_TimeStamp(){
3060 wxString msg;
3061 wxLog::TimeStamp(&msg);
3062 return msg;
3063 }
3064 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3065 // Make some wrappers that double any % signs so they are 'escaped'
3066 void wxPyLogFatalError(const wxString& msg)
3067 {
3068 wxString m(msg);
3069 m.Replace(wxT("%"), wxT("%%"));
3070 wxLogFatalError(m);
3071 }
3072
3073 void wxPyLogError(const wxString& msg)
3074 {
3075 wxString m(msg);
3076 m.Replace(wxT("%"), wxT("%%"));
3077 wxLogError(m);
3078 }
3079
3080 void wxPyLogWarning(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogWarning(m);
3085 }
3086
3087 void wxPyLogMessage(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogMessage(m);
3092 }
3093
3094 void wxPyLogInfo(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogInfo(m);
3099 }
3100
3101 void wxPyLogDebug(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogDebug(m);
3106 }
3107
3108 void wxPyLogVerbose(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogVerbose(m);
3113 }
3114
3115 void wxPyLogStatus(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogStatus(m);
3120 }
3121
3122 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogStatus(pFrame, m);
3127 }
3128
3129 void wxPyLogSysError(const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogSysError(m);
3134 }
3135
3136 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogGeneric(level, m);
3141 }
3142
3143 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogTrace(mask, m);
3148 }
3149
3150 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogTrace(mask, m);
3155 }
3156
3157
3158
3159 // A wxLog class that can be derived from in wxPython
3160 class wxPyLog : public wxLog {
3161 public:
3162 wxPyLog() : wxLog() {}
3163
3164 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3165 bool found;
3166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3167 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3168 PyObject* s = wx2PyString(szString);
3169 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3170 Py_DECREF(s);
3171 }
3172 wxPyEndBlockThreads(blocked);
3173 if (! found)
3174 wxLog::DoLog(level, szString, t);
3175 }
3176
3177 virtual void DoLogString(const wxChar *szString, time_t t) {
3178 bool found;
3179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3180 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3181 PyObject* s = wx2PyString(szString);
3182 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3183 Py_DECREF(s);
3184 }
3185 wxPyEndBlockThreads(blocked);
3186 if (! found)
3187 wxLog::DoLogString(szString, t);
3188 }
3189
3190 DEC_PYCALLBACK_VOID_(Flush);
3191 PYPRIVATE;
3192 };
3193 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3194
3195
3196
3197
3198 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3199
3200
3201 #include <wx/joystick.h>
3202
3203
3204 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3205 // A C++ stub class for wxJoystick for platforms that don't have it.
3206 class wxJoystick : public wxObject {
3207 public:
3208 wxJoystick(int joystick = wxJOYSTICK1) {
3209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3210 PyErr_SetString(PyExc_NotImplementedError,
3211 "wxJoystick is not available on this platform.");
3212 wxPyEndBlockThreads(blocked);
3213 }
3214 wxPoint GetPosition() { return wxPoint(-1,-1); }
3215 int GetZPosition() { return -1; }
3216 int GetButtonState() { return -1; }
3217 int GetPOVPosition() { return -1; }
3218 int GetPOVCTSPosition() { return -1; }
3219 int GetRudderPosition() { return -1; }
3220 int GetUPosition() { return -1; }
3221 int GetVPosition() { return -1; }
3222 int GetMovementThreshold() { return -1; }
3223 void SetMovementThreshold(int threshold) {}
3224
3225 bool IsOk(void) { return false; }
3226 int GetNumberJoysticks() { return -1; }
3227 int GetManufacturerId() { return -1; }
3228 int GetProductId() { return -1; }
3229 wxString GetProductName() { return wxEmptyString; }
3230 int GetXMin() { return -1; }
3231 int GetYMin() { return -1; }
3232 int GetZMin() { return -1; }
3233 int GetXMax() { return -1; }
3234 int GetYMax() { return -1; }
3235 int GetZMax() { return -1; }
3236 int GetNumberButtons() { return -1; }
3237 int GetNumberAxes() { return -1; }
3238 int GetMaxButtons() { return -1; }
3239 int GetMaxAxes() { return -1; }
3240 int GetPollingMin() { return -1; }
3241 int GetPollingMax() { return -1; }
3242 int GetRudderMin() { return -1; }
3243 int GetRudderMax() { return -1; }
3244 int GetUMin() { return -1; }
3245 int GetUMax() { return -1; }
3246 int GetVMin() { return -1; }
3247 int GetVMax() { return -1; }
3248
3249 bool HasRudder() { return false; }
3250 bool HasZ() { return false; }
3251 bool HasU() { return false; }
3252 bool HasV() { return false; }
3253 bool HasPOV() { return false; }
3254 bool HasPOV4Dir() { return false; }
3255 bool HasPOVCTS() { return false; }
3256
3257 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3258 bool ReleaseCapture() { return false; }
3259 };
3260 #endif
3261
3262
3263 #include <wx/sound.h>
3264
3265
3266 #if !wxUSE_SOUND
3267 // A C++ stub class for wxWave for platforms that don't have it.
3268 class wxSound : public wxObject
3269 {
3270 public:
3271 wxSound() {
3272 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3273 PyErr_SetString(PyExc_NotImplementedError,
3274 "wxSound is not available on this platform.");
3275 wxPyEndBlockThreads(blocked);
3276 }
3277 wxSound(const wxString&/*, bool*/) {
3278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3279 PyErr_SetString(PyExc_NotImplementedError,
3280 "wxSound is not available on this platform.");
3281 wxPyEndBlockThreads(blocked);
3282 }
3283 wxSound(int, const wxByte*) {
3284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3285 PyErr_SetString(PyExc_NotImplementedError,
3286 "wxSound is not available on this platform.");
3287 wxPyEndBlockThreads(blocked);
3288 }
3289
3290 ~wxSound() {};
3291
3292 bool Create(const wxString&/*, bool*/) { return false; }
3293 bool Create(int, const wxByte*) { return false; };
3294 bool IsOk() { return false; };
3295 bool Play(unsigned) const { return false; }
3296 static bool Play(const wxString&, unsigned) { return false; }
3297 static void Stop() {}
3298 };
3299
3300 #endif
3301
3302 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3303 if (fileName.Length() == 0)
3304 return new wxSound;
3305 else
3306 return new wxSound(fileName);
3307 }
3308 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3309 unsigned char* buffer; int size;
3310 wxSound *sound = NULL;
3311
3312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3313 if (!PyArg_Parse(data, "t#", &buffer, &size))
3314 goto done;
3315 sound = new wxSound(size, buffer);
3316 done:
3317 wxPyEndBlockThreads(blocked);
3318 return sound;
3319 }
3320 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3321 #ifndef __WXMAC__
3322 unsigned char* buffer;
3323 int size;
3324 bool rv = false;
3325
3326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3327 if (!PyArg_Parse(data, "t#", &buffer, &size))
3328 goto done;
3329 rv = self->Create(size, buffer);
3330 done:
3331 wxPyEndBlockThreads(blocked);
3332 return rv;
3333 #else
3334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3335 PyErr_SetString(PyExc_NotImplementedError,
3336 "Create from data is not available on this platform.");
3337 wxPyEndBlockThreads(blocked);
3338 return false;
3339 #endif
3340 }
3341
3342 #include <wx/mimetype.h>
3343
3344 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3345 wxString str;
3346 if (self->GetMimeType(&str))
3347 return wx2PyString(str);
3348 else
3349 RETURN_NONE();
3350 }
3351 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3352 wxArrayString arr;
3353 if (self->GetMimeTypes(arr))
3354 return wxArrayString2PyList_helper(arr);
3355 else
3356 RETURN_NONE();
3357 }
3358 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3359 wxArrayString arr;
3360 if (self->GetExtensions(arr))
3361 return wxArrayString2PyList_helper(arr);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3366 wxIconLocation loc;
3367 if (self->GetIcon(&loc))
3368 return new wxIcon(loc);
3369 else
3370 return NULL;
3371 }
3372 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3373 wxIconLocation loc;
3374 if (self->GetIcon(&loc)) {
3375 wxString iconFile = loc.GetFileName();
3376 int iconIndex = -1;
3377
3378 iconIndex = loc.GetIndex();
3379
3380 // Make a tuple and put the values in it
3381 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3382 PyObject* tuple = PyTuple_New(3);
3383 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3384 wxT("wxIcon"), true));
3385 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3386 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3387 wxPyEndBlockThreads(blocked);
3388 return tuple;
3389 }
3390 else
3391 RETURN_NONE();
3392 }
3393 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3394 wxString str;
3395 if (self->GetDescription(&str))
3396 return wx2PyString(str);
3397 else
3398 RETURN_NONE();
3399 }
3400 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3401 wxString str;
3402 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3403 return wx2PyString(str);
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3408 wxString str;
3409 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxArrayString verbs;
3416 wxArrayString commands;
3417 if (self->GetAllCommands(&verbs, &commands,
3418 wxFileType::MessageParameters(filename, mimetype))) {
3419 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3420 PyObject* tuple = PyTuple_New(2);
3421 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3422 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3423 wxPyEndBlockThreads(blocked);
3424 return tuple;
3425 }
3426 else
3427 RETURN_NONE();
3428 }
3429 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3430 return wxFileType::ExpandCommand(command,
3431 wxFileType::MessageParameters(filename, mimetype));
3432 }
3433 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3434 wxArrayString arr;
3435 self->EnumAllFileTypes(arr);
3436 return wxArrayString2PyList_helper(arr);
3437 }
3438
3439 #include <wx/artprov.h>
3440
3441 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3442 static const wxString wxPyART_MENU(wxART_MENU);
3443 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3444 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3445 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3446 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3447 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3448 static const wxString wxPyART_OTHER(wxART_OTHER);
3449 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3450 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3451 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3452 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3453 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3454 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3455 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3456 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3457 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3458 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3459 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3460 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3461 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3462 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3463 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3464 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3465 static const wxString wxPyART_PRINT(wxART_PRINT);
3466 static const wxString wxPyART_HELP(wxART_HELP);
3467 static const wxString wxPyART_TIP(wxART_TIP);
3468 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3469 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3470 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3471 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3472 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3473 static const wxString wxPyART_CDROM(wxART_CDROM);
3474 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3475 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3476 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3477 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3478 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3479 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3480 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3481 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3482 static const wxString wxPyART_ERROR(wxART_ERROR);
3483 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3484 static const wxString wxPyART_WARNING(wxART_WARNING);
3485 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3486 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3487 static const wxString wxPyART_COPY(wxART_COPY);
3488 static const wxString wxPyART_CUT(wxART_CUT);
3489 static const wxString wxPyART_PASTE(wxART_PASTE);
3490 static const wxString wxPyART_DELETE(wxART_DELETE);
3491 static const wxString wxPyART_NEW(wxART_NEW);
3492 static const wxString wxPyART_UNDO(wxART_UNDO);
3493 static const wxString wxPyART_REDO(wxART_REDO);
3494 static const wxString wxPyART_QUIT(wxART_QUIT);
3495 static const wxString wxPyART_FIND(wxART_FIND);
3496 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3497 // Python aware wxArtProvider
3498 class wxPyArtProvider : public wxArtProvider {
3499 public:
3500
3501 virtual wxBitmap CreateBitmap(const wxArtID& id,
3502 const wxArtClient& client,
3503 const wxSize& size) {
3504 wxBitmap rval = wxNullBitmap;
3505 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3506 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3507 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3508 PyObject* ro;
3509 wxBitmap* ptr;
3510 PyObject* s1, *s2;
3511 s1 = wx2PyString(id);
3512 s2 = wx2PyString(client);
3513 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3514 Py_DECREF(so);
3515 Py_DECREF(s1);
3516 Py_DECREF(s2);
3517 if (ro) {
3518 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3519 rval = *ptr;
3520 Py_DECREF(ro);
3521 }
3522 }
3523 wxPyEndBlockThreads(blocked);
3524 return rval;
3525 }
3526
3527 PYPRIVATE;
3528 };
3529
3530 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3531
3532
3533
3534 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3535 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3536 PyObject* ret = PyTuple_New(3);
3537 if (ret) {
3538 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3539 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3540 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3541 }
3542 wxPyEndBlockThreads(blocked);
3543 return ret;
3544 }
3545
3546 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3547 bool cont;
3548 long index = 0;
3549 wxString value;
3550
3551 cont = self->GetFirstGroup(value, index);
3552 return __EnumerationHelper(cont, value, index);
3553 }
3554 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3555 bool cont;
3556 wxString value;
3557
3558 cont = self->GetNextGroup(value, index);
3559 return __EnumerationHelper(cont, value, index);
3560 }
3561 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3562 bool cont;
3563 long index = 0;
3564 wxString value;
3565
3566 cont = self->GetFirstEntry(value, index);
3567 return __EnumerationHelper(cont, value, index);
3568 }
3569 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3570 bool cont;
3571 wxString value;
3572
3573 cont = self->GetNextEntry(value, index);
3574 return __EnumerationHelper(cont, value, index);
3575 }
3576 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3577 long rv;
3578 self->Read(key, &rv, defaultVal);
3579 return rv;
3580 }
3581
3582 SWIGINTERN int
3583 SWIG_AsVal_double (PyObject *obj, double* val)
3584 {
3585 if (PyNumber_Check(obj)) {
3586 if (val) *val = PyFloat_AsDouble(obj);
3587 return SWIG_OK;
3588 }
3589 return SWIG_TypeError;
3590 }
3591
3592 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3593 double rv;
3594 self->Read(key, &rv, defaultVal);
3595 return rv;
3596 }
3597
3598 #define SWIG_From_double PyFloat_FromDouble
3599
3600 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3601 bool rv;
3602 self->Read(key, &rv, defaultVal);
3603 return rv;
3604 }
3605
3606 #include <wx/datetime.h>
3607
3608 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3609 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3610
3611 #define LOCAL_TZ wxDateTime::Local
3612
3613 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3614 wxString am;
3615 wxString pm;
3616 wxDateTime::GetAmPmStrings(&am, &pm);
3617 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3618 PyObject* tup = PyTuple_New(2);
3619 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3620 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3621 wxPyEndBlockThreads(blocked);
3622 return tup;
3623 }
3624
3625 SWIGINTERNINLINE PyObject *
3626 SWIG_From_unsigned_SS_int (unsigned int value)
3627 {
3628 return SWIG_From_unsigned_SS_long (value);
3629 }
3630
3631 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3632 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3633 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3634 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3635 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3636 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3637 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3638 return (*self < *other);
3639 }
3640 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3641 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3642 return (*self <= *other);
3643 }
3644 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3645 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3646 return (*self > *other);
3647 }
3648 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3649 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3650 return (*self >= *other);
3651 }
3652 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3653 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3654 return (*self == *other);
3655 }
3656 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3658 return (*self != *other);
3659 }
3660 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3661 const wxChar* rv;
3662 const wxChar* _date = date;
3663 rv = self->ParseRfc822Date(_date);
3664 if (rv == NULL) return -1;
3665 return rv - _date;
3666 }
3667 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3668 const wxChar* rv;
3669 const wxChar* _date = date;
3670 rv = self->ParseFormat(_date, format, dateDef);
3671 if (rv == NULL) return -1;
3672 return rv - _date;
3673 }
3674 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3675 const wxChar* rv;
3676 const wxChar* _datetime = datetime;
3677 rv = self->ParseDateTime(_datetime);
3678 if (rv == NULL) return -1;
3679 return rv - _datetime;
3680 }
3681 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3682 const wxChar* rv;
3683 const wxChar* _date = date;
3684 rv = self->ParseDate(_date);
3685 if (rv == NULL) return -1;
3686 return rv - _date;
3687 }
3688 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3689 const wxChar* rv;
3690 const wxChar* _time = time;
3691 rv = self->ParseTime(_time);
3692 if (rv == NULL) return -1;
3693 return rv - _time;
3694 }
3695 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3696 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3697 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3698 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3699 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3700 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3701 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3702 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3703 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3704 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3705 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3706 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3707 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3708 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3709 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3710 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3711
3712 #include <wx/dataobj.h>
3713
3714 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3715 size_t count = self->GetFormatCount(dir);
3716 wxDataFormat* formats = new wxDataFormat[count];
3717 self->GetAllFormats(formats, dir);
3718
3719 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3720 PyObject* list = PyList_New(count);
3721 for (size_t i=0; i<count; i++) {
3722 wxDataFormat* format = new wxDataFormat(formats[i]);
3723 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3724 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3725 }
3726 wxPyEndBlockThreads(blocked);
3727 delete [] formats;
3728 return list;
3729 }
3730 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3731 PyObject* rval = NULL;
3732 size_t size = self->GetDataSize(format);
3733 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3734 if (size) {
3735 char* buf = new char[size];
3736 if (self->GetDataHere(format, buf))
3737 rval = PyString_FromStringAndSize(buf, size);
3738 delete [] buf;
3739 }
3740 if (! rval) {
3741 rval = Py_None;
3742 Py_INCREF(rval);
3743 }
3744 wxPyEndBlockThreads(blocked);
3745 return rval;
3746 }
3747 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3748 bool rval;
3749 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3750 if (PyString_Check(data)) {
3751 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3752 }
3753 else {
3754 // raise a TypeError if not a string
3755 PyErr_SetString(PyExc_TypeError, "String expected.");
3756 rval = false;
3757 }
3758 wxPyEndBlockThreads(blocked);
3759 return rval;
3760 }
3761 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3762 PyObject* rval = NULL;
3763 size_t size = self->GetDataSize();
3764 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3765 if (size) {
3766 char* buf = new char[size];
3767 if (self->GetDataHere(buf))
3768 rval = PyString_FromStringAndSize(buf, size);
3769 delete [] buf;
3770 }
3771 if (! rval) {
3772 rval = Py_None;
3773 Py_INCREF(rval);
3774 }
3775 wxPyEndBlockThreads(blocked);
3776 return rval;
3777 }
3778 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3779 bool rval;
3780 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3781 if (PyString_Check(data)) {
3782 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3783 }
3784 else {
3785 // raise a TypeError if not a string
3786 PyErr_SetString(PyExc_TypeError, "String expected.");
3787 rval = false;
3788 }
3789 wxPyEndBlockThreads(blocked);
3790 return rval;
3791 }
3792 // Create a new class for wxPython to use
3793 class wxPyDataObjectSimple : public wxDataObjectSimple {
3794 public:
3795 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3796 : wxDataObjectSimple(format) {}
3797
3798 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3799 bool GetDataHere(void *buf) const;
3800 bool SetData(size_t len, const void *buf) const;
3801 PYPRIVATE;
3802 };
3803
3804 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3805
3806 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3807 // We need to get the data for this object and write it to buf. I think
3808 // the best way to do this for wxPython is to have the Python method
3809 // return either a string or None and then act appropriately with the
3810 // C++ version.
3811
3812 bool rval = false;
3813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3814 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3815 PyObject* ro;
3816 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3817 if (ro) {
3818 rval = (ro != Py_None && PyString_Check(ro));
3819 if (rval)
3820 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3821 Py_DECREF(ro);
3822 }
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return rval;
3826 }
3827
3828 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3829 // For this one we simply need to make a string from buf and len
3830 // and send it to the Python method.
3831 bool rval = false;
3832 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3833 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3834 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3835 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3836 Py_DECREF(data);
3837 }
3838 wxPyEndBlockThreads(blocked);
3839 return rval;
3840 }
3841
3842 // Create a new class for wxPython to use
3843 class wxPyTextDataObject : public wxTextDataObject {
3844 public:
3845 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3846 : wxTextDataObject(text) {}
3847
3848 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3849 DEC_PYCALLBACK_STRING__const(GetText);
3850 DEC_PYCALLBACK__STRING(SetText);
3851 PYPRIVATE;
3852 };
3853
3854 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3855 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3856 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3857
3858
3859 // Create a new class for wxPython to use
3860 class wxPyBitmapDataObject : public wxBitmapDataObject {
3861 public:
3862 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3863 : wxBitmapDataObject(bitmap) {}
3864
3865 wxBitmap GetBitmap() const;
3866 void SetBitmap(const wxBitmap& bitmap);
3867 PYPRIVATE;
3868 };
3869
3870 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3871 wxBitmap* rval = &wxNullBitmap;
3872 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3873 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3874 PyObject* ro;
3875 wxBitmap* ptr;
3876 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3877 if (ro) {
3878 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3879 rval = ptr;
3880 Py_DECREF(ro);
3881 }
3882 }
3883 wxPyEndBlockThreads(blocked);
3884 return *rval;
3885 }
3886
3887 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3888 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3889 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3890 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3891 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3892 Py_DECREF(bo);
3893 }
3894 wxPyEndBlockThreads(blocked);
3895 }
3896
3897 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3898 return new wxCustomDataObject(wxDataFormat(formatName));
3899 }
3900 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3901 bool rval;
3902 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3903 if (PyString_Check(data)) {
3904 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3905 }
3906 else {
3907 // raise a TypeError if not a string
3908 PyErr_SetString(PyExc_TypeError, "String expected.");
3909 rval = false;
3910 }
3911 wxPyEndBlockThreads(blocked);
3912 return rval;
3913 }
3914 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3915 PyObject* obj;
3916 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3917 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3918 wxPyEndBlockThreads(blocked);
3919 return obj;
3920 }
3921
3922 #include <wx/metafile.h>
3923
3924
3925 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3926
3927
3928 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3929 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3930 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3931 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3932 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3933
3934
3935 class wxPyTextDropTarget : public wxTextDropTarget {
3936 public:
3937 wxPyTextDropTarget() {}
3938
3939 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3940
3941 DEC_PYCALLBACK__(OnLeave);
3942 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3943 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3944 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3945 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3946
3947 PYPRIVATE;
3948 };
3949
3950 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3951 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3952 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3953 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3954 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3955 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3956
3957
3958
3959 class wxPyFileDropTarget : public wxFileDropTarget {
3960 public:
3961 wxPyFileDropTarget() {}
3962
3963 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3964
3965 DEC_PYCALLBACK__(OnLeave);
3966 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3967 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3968 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3969 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3970
3971 PYPRIVATE;
3972 };
3973
3974 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3975 const wxArrayString& filenames) {
3976 bool rval = false;
3977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3978 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3979 PyObject* list = wxArrayString2PyList_helper(filenames);
3980 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3981 Py_DECREF(list);
3982 }
3983 wxPyEndBlockThreads(blocked);
3984 return rval;
3985 }
3986
3987
3988
3989 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3990 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3991 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3992 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3993 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3994
3995
3996
3997
3998 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
3999
4000 #include <wx/display.h>
4001
4002 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4003 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4004
4005 #if !wxUSE_DISPLAY
4006 const wxVideoMode wxDefaultVideoMode;
4007 #endif
4008
4009 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4010 #if wxUSE_DISPLAY
4011 PyObject* pyList = NULL;
4012 wxArrayVideoModes arr = self->GetModes(mode);
4013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4014 pyList = PyList_New(0);
4015 for (size_t i=0; i < arr.GetCount(); i++)
4016 {
4017 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4018 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4019 PyList_Append(pyList, pyObj);
4020 Py_DECREF(pyObj);
4021 }
4022 wxPyEndBlockThreads(blocked);
4023 return pyList;
4024 #else
4025 wxPyRaiseNotImplemented();
4026 return NULL;
4027 #endif
4028 }
4029 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4030 #if wxUSE_DISPLAY
4031 return self->GetCurrentMode();
4032 #else
4033 wxPyRaiseNotImplemented();
4034 return wxDefaultVideoMode;
4035 #endif
4036 }
4037 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4038 #if wxUSE_DISPLAY
4039 return self->ChangeMode(mode);
4040 #else
4041 wxPyRaiseNotImplemented();
4042 return false;
4043 #endif
4044 }
4045 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4046 #if wxUSE_DISPLAY
4047 self->ResetMode();
4048 #else
4049 wxPyRaiseNotImplemented();
4050 #endif
4051 }
4052
4053 #include <wx/stdpaths.h>
4054
4055 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4056 return (wxStandardPaths*) &wxStandardPaths::Get();
4057 }
4058 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4059 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4060 #ifdef __cplusplus
4061 extern "C" {
4062 #endif
4063 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4064 PyObject *resultobj = 0;
4065 wxSystemColour arg1 ;
4066 wxColour result;
4067 int val1 ;
4068 int ecode1 = 0 ;
4069 PyObject * obj0 = 0 ;
4070 char * kwnames[] = {
4071 (char *) "index", NULL
4072 };
4073
4074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4075 ecode1 = SWIG_AsVal_int(obj0, &val1);
4076 if (!SWIG_IsOK(ecode1)) {
4077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4078 }
4079 arg1 = static_cast< wxSystemColour >(val1);
4080 {
4081 if (!wxPyCheckForApp()) SWIG_fail;
4082 PyThreadState* __tstate = wxPyBeginAllowThreads();
4083 result = wxSystemSettings::GetColour(arg1);
4084 wxPyEndAllowThreads(__tstate);
4085 if (PyErr_Occurred()) SWIG_fail;
4086 }
4087 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4088 return resultobj;
4089 fail:
4090 return NULL;
4091 }
4092
4093
4094 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj = 0;
4096 wxSystemFont arg1 ;
4097 wxFont result;
4098 int val1 ;
4099 int ecode1 = 0 ;
4100 PyObject * obj0 = 0 ;
4101 char * kwnames[] = {
4102 (char *) "index", NULL
4103 };
4104
4105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4106 ecode1 = SWIG_AsVal_int(obj0, &val1);
4107 if (!SWIG_IsOK(ecode1)) {
4108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4109 }
4110 arg1 = static_cast< wxSystemFont >(val1);
4111 {
4112 if (!wxPyCheckForApp()) SWIG_fail;
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = wxSystemSettings::GetFont(arg1);
4115 wxPyEndAllowThreads(__tstate);
4116 if (PyErr_Occurred()) SWIG_fail;
4117 }
4118 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4119 return resultobj;
4120 fail:
4121 return NULL;
4122 }
4123
4124
4125 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4126 PyObject *resultobj = 0;
4127 wxSystemMetric arg1 ;
4128 wxWindow *arg2 = (wxWindow *) NULL ;
4129 int result;
4130 int val1 ;
4131 int ecode1 = 0 ;
4132 void *argp2 = 0 ;
4133 int res2 = 0 ;
4134 PyObject * obj0 = 0 ;
4135 PyObject * obj1 = 0 ;
4136 char * kwnames[] = {
4137 (char *) "index",(char *) "win", NULL
4138 };
4139
4140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4141 ecode1 = SWIG_AsVal_int(obj0, &val1);
4142 if (!SWIG_IsOK(ecode1)) {
4143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4144 }
4145 arg1 = static_cast< wxSystemMetric >(val1);
4146 if (obj1) {
4147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4148 if (!SWIG_IsOK(res2)) {
4149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4150 }
4151 arg2 = reinterpret_cast< wxWindow * >(argp2);
4152 }
4153 {
4154 if (!wxPyCheckForApp()) SWIG_fail;
4155 PyThreadState* __tstate = wxPyBeginAllowThreads();
4156 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4157 wxPyEndAllowThreads(__tstate);
4158 if (PyErr_Occurred()) SWIG_fail;
4159 }
4160 resultobj = SWIG_From_int(static_cast< int >(result));
4161 return resultobj;
4162 fail:
4163 return NULL;
4164 }
4165
4166
4167 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4168 PyObject *resultobj = 0;
4169 wxSystemFeature arg1 ;
4170 bool result;
4171 int val1 ;
4172 int ecode1 = 0 ;
4173 PyObject * obj0 = 0 ;
4174 char * kwnames[] = {
4175 (char *) "index", NULL
4176 };
4177
4178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4179 ecode1 = SWIG_AsVal_int(obj0, &val1);
4180 if (!SWIG_IsOK(ecode1)) {
4181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4182 }
4183 arg1 = static_cast< wxSystemFeature >(val1);
4184 {
4185 if (!wxPyCheckForApp()) SWIG_fail;
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = (bool)wxSystemSettings::HasFeature(arg1);
4188 wxPyEndAllowThreads(__tstate);
4189 if (PyErr_Occurred()) SWIG_fail;
4190 }
4191 {
4192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4193 }
4194 return resultobj;
4195 fail:
4196 return NULL;
4197 }
4198
4199
4200 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4201 PyObject *resultobj = 0;
4202 wxSystemScreenType result;
4203
4204 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4205 {
4206 if (!wxPyCheckForApp()) SWIG_fail;
4207 PyThreadState* __tstate = wxPyBeginAllowThreads();
4208 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 resultobj = SWIG_From_int(static_cast< int >(result));
4213 return resultobj;
4214 fail:
4215 return NULL;
4216 }
4217
4218
4219 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4220 PyObject *resultobj = 0;
4221 wxSystemScreenType arg1 ;
4222 int val1 ;
4223 int ecode1 = 0 ;
4224 PyObject * obj0 = 0 ;
4225 char * kwnames[] = {
4226 (char *) "screen", NULL
4227 };
4228
4229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4230 ecode1 = SWIG_AsVal_int(obj0, &val1);
4231 if (!SWIG_IsOK(ecode1)) {
4232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4233 }
4234 arg1 = static_cast< wxSystemScreenType >(val1);
4235 {
4236 if (!wxPyCheckForApp()) SWIG_fail;
4237 PyThreadState* __tstate = wxPyBeginAllowThreads();
4238 wxSystemSettings::SetScreenType(arg1);
4239 wxPyEndAllowThreads(__tstate);
4240 if (PyErr_Occurred()) SWIG_fail;
4241 }
4242 resultobj = SWIG_Py_Void();
4243 return resultobj;
4244 fail:
4245 return NULL;
4246 }
4247
4248
4249 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4250 PyObject *obj;
4251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4252 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4253 return SWIG_Py_Void();
4254 }
4255
4256 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4257 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4258 return 1;
4259 }
4260
4261
4262 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4263 PyObject *pyobj = 0;
4264
4265 {
4266 #if wxUSE_UNICODE
4267 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4268 #else
4269 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4270 #endif
4271 }
4272 return pyobj;
4273 }
4274
4275
4276 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4277 PyObject *resultobj = 0;
4278 wxSystemOptions *result = 0 ;
4279
4280 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4281 {
4282 PyThreadState* __tstate = wxPyBeginAllowThreads();
4283 result = (wxSystemOptions *)new wxSystemOptions();
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4288 return resultobj;
4289 fail:
4290 return NULL;
4291 }
4292
4293
4294 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj = 0;
4296 wxString *arg1 = 0 ;
4297 wxString *arg2 = 0 ;
4298 bool temp1 = false ;
4299 bool temp2 = false ;
4300 PyObject * obj0 = 0 ;
4301 PyObject * obj1 = 0 ;
4302 char * kwnames[] = {
4303 (char *) "name",(char *) "value", NULL
4304 };
4305
4306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4307 {
4308 arg1 = wxString_in_helper(obj0);
4309 if (arg1 == NULL) SWIG_fail;
4310 temp1 = true;
4311 }
4312 {
4313 arg2 = wxString_in_helper(obj1);
4314 if (arg2 == NULL) SWIG_fail;
4315 temp2 = true;
4316 }
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = SWIG_Py_Void();
4324 {
4325 if (temp1)
4326 delete arg1;
4327 }
4328 {
4329 if (temp2)
4330 delete arg2;
4331 }
4332 return resultobj;
4333 fail:
4334 {
4335 if (temp1)
4336 delete arg1;
4337 }
4338 {
4339 if (temp2)
4340 delete arg2;
4341 }
4342 return NULL;
4343 }
4344
4345
4346 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4347 PyObject *resultobj = 0;
4348 wxString *arg1 = 0 ;
4349 int arg2 ;
4350 bool temp1 = false ;
4351 int val2 ;
4352 int ecode2 = 0 ;
4353 PyObject * obj0 = 0 ;
4354 PyObject * obj1 = 0 ;
4355 char * kwnames[] = {
4356 (char *) "name",(char *) "value", NULL
4357 };
4358
4359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4360 {
4361 arg1 = wxString_in_helper(obj0);
4362 if (arg1 == NULL) SWIG_fail;
4363 temp1 = true;
4364 }
4365 ecode2 = SWIG_AsVal_int(obj1, &val2);
4366 if (!SWIG_IsOK(ecode2)) {
4367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4368 }
4369 arg2 = static_cast< int >(val2);
4370 {
4371 PyThreadState* __tstate = wxPyBeginAllowThreads();
4372 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4373 wxPyEndAllowThreads(__tstate);
4374 if (PyErr_Occurred()) SWIG_fail;
4375 }
4376 resultobj = SWIG_Py_Void();
4377 {
4378 if (temp1)
4379 delete arg1;
4380 }
4381 return resultobj;
4382 fail:
4383 {
4384 if (temp1)
4385 delete arg1;
4386 }
4387 return NULL;
4388 }
4389
4390
4391 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj = 0;
4393 wxString *arg1 = 0 ;
4394 wxString result;
4395 bool temp1 = false ;
4396 PyObject * obj0 = 0 ;
4397 char * kwnames[] = {
4398 (char *) "name", NULL
4399 };
4400
4401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4402 {
4403 arg1 = wxString_in_helper(obj0);
4404 if (arg1 == NULL) SWIG_fail;
4405 temp1 = true;
4406 }
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4410 wxPyEndAllowThreads(__tstate);
4411 if (PyErr_Occurred()) SWIG_fail;
4412 }
4413 {
4414 #if wxUSE_UNICODE
4415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4416 #else
4417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4418 #endif
4419 }
4420 {
4421 if (temp1)
4422 delete arg1;
4423 }
4424 return resultobj;
4425 fail:
4426 {
4427 if (temp1)
4428 delete arg1;
4429 }
4430 return NULL;
4431 }
4432
4433
4434 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4435 PyObject *resultobj = 0;
4436 wxString *arg1 = 0 ;
4437 int result;
4438 bool temp1 = false ;
4439 PyObject * obj0 = 0 ;
4440 char * kwnames[] = {
4441 (char *) "name", NULL
4442 };
4443
4444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4445 {
4446 arg1 = wxString_in_helper(obj0);
4447 if (arg1 == NULL) SWIG_fail;
4448 temp1 = true;
4449 }
4450 {
4451 PyThreadState* __tstate = wxPyBeginAllowThreads();
4452 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4453 wxPyEndAllowThreads(__tstate);
4454 if (PyErr_Occurred()) SWIG_fail;
4455 }
4456 resultobj = SWIG_From_int(static_cast< int >(result));
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return resultobj;
4462 fail:
4463 {
4464 if (temp1)
4465 delete arg1;
4466 }
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj = 0;
4473 wxString *arg1 = 0 ;
4474 bool result;
4475 bool temp1 = false ;
4476 PyObject * obj0 = 0 ;
4477 char * kwnames[] = {
4478 (char *) "name", NULL
4479 };
4480
4481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4482 {
4483 arg1 = wxString_in_helper(obj0);
4484 if (arg1 == NULL) SWIG_fail;
4485 temp1 = true;
4486 }
4487 {
4488 PyThreadState* __tstate = wxPyBeginAllowThreads();
4489 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 {
4494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4495 }
4496 {
4497 if (temp1)
4498 delete arg1;
4499 }
4500 return resultobj;
4501 fail:
4502 {
4503 if (temp1)
4504 delete arg1;
4505 }
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4511 PyObject *resultobj = 0;
4512 wxString *arg1 = 0 ;
4513 bool result;
4514 bool temp1 = false ;
4515 PyObject * obj0 = 0 ;
4516 char * kwnames[] = {
4517 (char *) "name", NULL
4518 };
4519
4520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4521 {
4522 arg1 = wxString_in_helper(obj0);
4523 if (arg1 == NULL) SWIG_fail;
4524 temp1 = true;
4525 }
4526 {
4527 PyThreadState* __tstate = wxPyBeginAllowThreads();
4528 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4529 wxPyEndAllowThreads(__tstate);
4530 if (PyErr_Occurred()) SWIG_fail;
4531 }
4532 {
4533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4534 }
4535 {
4536 if (temp1)
4537 delete arg1;
4538 }
4539 return resultobj;
4540 fail:
4541 {
4542 if (temp1)
4543 delete arg1;
4544 }
4545 return NULL;
4546 }
4547
4548
4549 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4550 PyObject *obj;
4551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4552 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4553 return SWIG_Py_Void();
4554 }
4555
4556 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4557 return SWIG_Python_InitShadowInstance(args);
4558 }
4559
4560 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4561 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4562 return 1;
4563 }
4564
4565
4566 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4567 PyObject *pyobj = 0;
4568
4569 {
4570 #if wxUSE_UNICODE
4571 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4572 #else
4573 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4574 #endif
4575 }
4576 return pyobj;
4577 }
4578
4579
4580 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4581 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4582 return 1;
4583 }
4584
4585
4586 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4587 PyObject *pyobj = 0;
4588
4589 {
4590 #if wxUSE_UNICODE
4591 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4592 #else
4593 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4594 #endif
4595 }
4596 return pyobj;
4597 }
4598
4599
4600 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4601 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4602 return 1;
4603 }
4604
4605
4606 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4607 PyObject *pyobj = 0;
4608
4609 {
4610 #if wxUSE_UNICODE
4611 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4612 #else
4613 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4614 #endif
4615 }
4616 return pyobj;
4617 }
4618
4619
4620 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4621 PyObject *resultobj = 0;
4622 long result;
4623
4624 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4625 {
4626 PyThreadState* __tstate = wxPyBeginAllowThreads();
4627 result = (long)wxNewId();
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 resultobj = SWIG_From_long(static_cast< long >(result));
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = 0;
4640 long arg1 ;
4641 long val1 ;
4642 int ecode1 = 0 ;
4643 PyObject * obj0 = 0 ;
4644 char * kwnames[] = {
4645 (char *) "id", NULL
4646 };
4647
4648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4649 ecode1 = SWIG_AsVal_long(obj0, &val1);
4650 if (!SWIG_IsOK(ecode1)) {
4651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4652 }
4653 arg1 = static_cast< long >(val1);
4654 {
4655 PyThreadState* __tstate = wxPyBeginAllowThreads();
4656 wxRegisterId(arg1);
4657 wxPyEndAllowThreads(__tstate);
4658 if (PyErr_Occurred()) SWIG_fail;
4659 }
4660 resultobj = SWIG_Py_Void();
4661 return resultobj;
4662 fail:
4663 return NULL;
4664 }
4665
4666
4667 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4668 PyObject *resultobj = 0;
4669 long result;
4670
4671 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4672 {
4673 PyThreadState* __tstate = wxPyBeginAllowThreads();
4674 result = (long)wxGetCurrentId();
4675 wxPyEndAllowThreads(__tstate);
4676 if (PyErr_Occurred()) SWIG_fail;
4677 }
4678 resultobj = SWIG_From_long(static_cast< long >(result));
4679 return resultobj;
4680 fail:
4681 return NULL;
4682 }
4683
4684
4685 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4686 PyObject *resultobj = 0;
4687 int arg1 ;
4688 bool result;
4689 int val1 ;
4690 int ecode1 = 0 ;
4691 PyObject * obj0 = 0 ;
4692 char * kwnames[] = {
4693 (char *) "id", NULL
4694 };
4695
4696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4697 ecode1 = SWIG_AsVal_int(obj0, &val1);
4698 if (!SWIG_IsOK(ecode1)) {
4699 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4700 }
4701 arg1 = static_cast< int >(val1);
4702 {
4703 PyThreadState* __tstate = wxPyBeginAllowThreads();
4704 result = (bool)wxIsStockID(arg1);
4705 wxPyEndAllowThreads(__tstate);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 {
4709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4710 }
4711 return resultobj;
4712 fail:
4713 return NULL;
4714 }
4715
4716
4717 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4718 PyObject *resultobj = 0;
4719 int arg1 ;
4720 wxString *arg2 = 0 ;
4721 bool result;
4722 int val1 ;
4723 int ecode1 = 0 ;
4724 bool temp2 = false ;
4725 PyObject * obj0 = 0 ;
4726 PyObject * obj1 = 0 ;
4727 char * kwnames[] = {
4728 (char *) "id",(char *) "label", NULL
4729 };
4730
4731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4732 ecode1 = SWIG_AsVal_int(obj0, &val1);
4733 if (!SWIG_IsOK(ecode1)) {
4734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4735 }
4736 arg1 = static_cast< int >(val1);
4737 {
4738 arg2 = wxString_in_helper(obj1);
4739 if (arg2 == NULL) SWIG_fail;
4740 temp2 = true;
4741 }
4742 {
4743 PyThreadState* __tstate = wxPyBeginAllowThreads();
4744 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4745 wxPyEndAllowThreads(__tstate);
4746 if (PyErr_Occurred()) SWIG_fail;
4747 }
4748 {
4749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4750 }
4751 {
4752 if (temp2)
4753 delete arg2;
4754 }
4755 return resultobj;
4756 fail:
4757 {
4758 if (temp2)
4759 delete arg2;
4760 }
4761 return NULL;
4762 }
4763
4764
4765 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4766 PyObject *resultobj = 0;
4767 int arg1 ;
4768 bool arg2 = (bool) true ;
4769 wxString arg3 = (wxString) wxPyEmptyString ;
4770 wxString result;
4771 int val1 ;
4772 int ecode1 = 0 ;
4773 bool val2 ;
4774 int ecode2 = 0 ;
4775 PyObject * obj0 = 0 ;
4776 PyObject * obj1 = 0 ;
4777 PyObject * obj2 = 0 ;
4778 char * kwnames[] = {
4779 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4780 };
4781
4782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4783 ecode1 = SWIG_AsVal_int(obj0, &val1);
4784 if (!SWIG_IsOK(ecode1)) {
4785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4786 }
4787 arg1 = static_cast< int >(val1);
4788 if (obj1) {
4789 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4790 if (!SWIG_IsOK(ecode2)) {
4791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4792 }
4793 arg2 = static_cast< bool >(val2);
4794 }
4795 if (obj2) {
4796 {
4797 wxString* sptr = wxString_in_helper(obj2);
4798 if (sptr == NULL) SWIG_fail;
4799 arg3 = *sptr;
4800 delete sptr;
4801 }
4802 }
4803 {
4804 PyThreadState* __tstate = wxPyBeginAllowThreads();
4805 result = wxGetStockLabel(arg1,arg2,arg3);
4806 wxPyEndAllowThreads(__tstate);
4807 if (PyErr_Occurred()) SWIG_fail;
4808 }
4809 {
4810 #if wxUSE_UNICODE
4811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4812 #else
4813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4814 #endif
4815 }
4816 return resultobj;
4817 fail:
4818 return NULL;
4819 }
4820
4821
4822 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4823 PyObject *resultobj = 0;
4824
4825 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4826 {
4827 if (!wxPyCheckForApp()) SWIG_fail;
4828 PyThreadState* __tstate = wxPyBeginAllowThreads();
4829 wxBell();
4830 wxPyEndAllowThreads(__tstate);
4831 if (PyErr_Occurred()) SWIG_fail;
4832 }
4833 resultobj = SWIG_Py_Void();
4834 return resultobj;
4835 fail:
4836 return NULL;
4837 }
4838
4839
4840 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4841 PyObject *resultobj = 0;
4842
4843 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4844 {
4845 if (!wxPyCheckForApp()) SWIG_fail;
4846 PyThreadState* __tstate = wxPyBeginAllowThreads();
4847 wxEndBusyCursor();
4848 wxPyEndAllowThreads(__tstate);
4849 if (PyErr_Occurred()) SWIG_fail;
4850 }
4851 resultobj = SWIG_Py_Void();
4852 return resultobj;
4853 fail:
4854 return NULL;
4855 }
4856
4857
4858 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj = 0;
4860 bool arg1 = (bool) true ;
4861 long result;
4862 bool val1 ;
4863 int ecode1 = 0 ;
4864 PyObject * obj0 = 0 ;
4865 char * kwnames[] = {
4866 (char *) "resetTimer", NULL
4867 };
4868
4869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4870 if (obj0) {
4871 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4872 if (!SWIG_IsOK(ecode1)) {
4873 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4874 }
4875 arg1 = static_cast< bool >(val1);
4876 }
4877 {
4878 PyThreadState* __tstate = wxPyBeginAllowThreads();
4879 result = (long)wxGetElapsedTime(arg1);
4880 wxPyEndAllowThreads(__tstate);
4881 if (PyErr_Occurred()) SWIG_fail;
4882 }
4883 resultobj = SWIG_From_long(static_cast< long >(result));
4884 return resultobj;
4885 fail:
4886 return NULL;
4887 }
4888
4889
4890 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4891 PyObject *resultobj = 0;
4892 bool result;
4893
4894 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4895 {
4896 PyThreadState* __tstate = wxPyBeginAllowThreads();
4897 result = (bool)wxIsBusy();
4898 wxPyEndAllowThreads(__tstate);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 {
4902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4903 }
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4911 PyObject *resultobj = 0;
4912 wxString result;
4913
4914 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 result = wxNow();
4918 wxPyEndAllowThreads(__tstate);
4919 if (PyErr_Occurred()) SWIG_fail;
4920 }
4921 {
4922 #if wxUSE_UNICODE
4923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4924 #else
4925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4926 #endif
4927 }
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj = 0;
4936 wxString const &arg1_defvalue = wxPyEmptyString ;
4937 wxString *arg1 = (wxString *) &arg1_defvalue ;
4938 bool result;
4939 bool temp1 = false ;
4940 PyObject * obj0 = 0 ;
4941 char * kwnames[] = {
4942 (char *) "command", NULL
4943 };
4944
4945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4946 if (obj0) {
4947 {
4948 arg1 = wxString_in_helper(obj0);
4949 if (arg1 == NULL) SWIG_fail;
4950 temp1 = true;
4951 }
4952 }
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 result = (bool)wxShell((wxString const &)*arg1);
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 {
4960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4961 }
4962 {
4963 if (temp1)
4964 delete arg1;
4965 }
4966 return resultobj;
4967 fail:
4968 {
4969 if (temp1)
4970 delete arg1;
4971 }
4972 return NULL;
4973 }
4974
4975
4976 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4977 PyObject *resultobj = 0;
4978
4979 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 wxStartTimer();
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 resultobj = SWIG_Py_Void();
4987 return resultobj;
4988 fail:
4989 return NULL;
4990 }
4991
4992
4993 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4994 PyObject *resultobj = 0;
4995 int *arg1 = (int *) 0 ;
4996 int *arg2 = (int *) 0 ;
4997 int result;
4998 int temp1 ;
4999 int res1 = SWIG_TMPOBJ ;
5000 int temp2 ;
5001 int res2 = SWIG_TMPOBJ ;
5002
5003 arg1 = &temp1;
5004 arg2 = &temp2;
5005 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5006 {
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 result = (int)wxGetOsVersion(arg1,arg2);
5009 wxPyEndAllowThreads(__tstate);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 resultobj = SWIG_From_int(static_cast< int >(result));
5013 if (SWIG_IsTmpObj(res1)) {
5014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5015 } else {
5016 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5018 }
5019 if (SWIG_IsTmpObj(res2)) {
5020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5021 } else {
5022 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5023 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5024 }
5025 return resultobj;
5026 fail:
5027 return NULL;
5028 }
5029
5030
5031 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5032 PyObject *resultobj = 0;
5033 wxString result;
5034
5035 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5036 {
5037 PyThreadState* __tstate = wxPyBeginAllowThreads();
5038 result = wxGetOsDescription();
5039 wxPyEndAllowThreads(__tstate);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 {
5043 #if wxUSE_UNICODE
5044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5045 #else
5046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5047 #endif
5048 }
5049 return resultobj;
5050 fail:
5051 return NULL;
5052 }
5053
5054
5055 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5056 PyObject *resultobj = 0;
5057 wxMemorySize result;
5058
5059 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5060 {
5061 PyThreadState* __tstate = wxPyBeginAllowThreads();
5062 result = wxGetFreeMemory();
5063 wxPyEndAllowThreads(__tstate);
5064 if (PyErr_Occurred()) SWIG_fail;
5065 }
5066 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5067 return resultobj;
5068 fail:
5069 return NULL;
5070 }
5071
5072
5073 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5074 PyObject *resultobj = 0;
5075 wxShutdownFlags arg1 ;
5076 bool result;
5077 int val1 ;
5078 int ecode1 = 0 ;
5079 PyObject * obj0 = 0 ;
5080 char * kwnames[] = {
5081 (char *) "wFlags", NULL
5082 };
5083
5084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5085 ecode1 = SWIG_AsVal_int(obj0, &val1);
5086 if (!SWIG_IsOK(ecode1)) {
5087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5088 }
5089 arg1 = static_cast< wxShutdownFlags >(val1);
5090 {
5091 if (!wxPyCheckForApp()) SWIG_fail;
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = (bool)wxShutdown(arg1);
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5099 }
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj = 0;
5108 int arg1 ;
5109 int val1 ;
5110 int ecode1 = 0 ;
5111 PyObject * obj0 = 0 ;
5112 char * kwnames[] = {
5113 (char *) "secs", NULL
5114 };
5115
5116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5117 ecode1 = SWIG_AsVal_int(obj0, &val1);
5118 if (!SWIG_IsOK(ecode1)) {
5119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5120 }
5121 arg1 = static_cast< int >(val1);
5122 {
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 wxSleep(arg1);
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 resultobj = SWIG_Py_Void();
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5136 PyObject *resultobj = 0;
5137 unsigned long arg1 ;
5138 unsigned long val1 ;
5139 int ecode1 = 0 ;
5140 PyObject * obj0 = 0 ;
5141 char * kwnames[] = {
5142 (char *) "milliseconds", NULL
5143 };
5144
5145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5146 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5147 if (!SWIG_IsOK(ecode1)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5149 }
5150 arg1 = static_cast< unsigned long >(val1);
5151 {
5152 PyThreadState* __tstate = wxPyBeginAllowThreads();
5153 wxMilliSleep(arg1);
5154 wxPyEndAllowThreads(__tstate);
5155 if (PyErr_Occurred()) SWIG_fail;
5156 }
5157 resultobj = SWIG_Py_Void();
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5165 PyObject *resultobj = 0;
5166 unsigned long arg1 ;
5167 unsigned long val1 ;
5168 int ecode1 = 0 ;
5169 PyObject * obj0 = 0 ;
5170 char * kwnames[] = {
5171 (char *) "microseconds", NULL
5172 };
5173
5174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5175 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5176 if (!SWIG_IsOK(ecode1)) {
5177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5178 }
5179 arg1 = static_cast< unsigned long >(val1);
5180 {
5181 PyThreadState* __tstate = wxPyBeginAllowThreads();
5182 wxMicroSleep(arg1);
5183 wxPyEndAllowThreads(__tstate);
5184 if (PyErr_Occurred()) SWIG_fail;
5185 }
5186 resultobj = SWIG_Py_Void();
5187 return resultobj;
5188 fail:
5189 return NULL;
5190 }
5191
5192
5193 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5194 PyObject *resultobj = 0;
5195 bool arg1 ;
5196 bool val1 ;
5197 int ecode1 = 0 ;
5198 PyObject * obj0 = 0 ;
5199 char * kwnames[] = {
5200 (char *) "enable", NULL
5201 };
5202
5203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5204 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5205 if (!SWIG_IsOK(ecode1)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5207 }
5208 arg1 = static_cast< bool >(val1);
5209 {
5210 PyThreadState* __tstate = wxPyBeginAllowThreads();
5211 wxEnableTopLevelWindows(arg1);
5212 wxPyEndAllowThreads(__tstate);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 resultobj = SWIG_Py_Void();
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 wxString *arg1 = 0 ;
5225 wxString result;
5226 bool temp1 = false ;
5227 PyObject * obj0 = 0 ;
5228 char * kwnames[] = {
5229 (char *) "in", NULL
5230 };
5231
5232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5233 {
5234 arg1 = wxString_in_helper(obj0);
5235 if (arg1 == NULL) SWIG_fail;
5236 temp1 = true;
5237 }
5238 {
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 result = wxStripMenuCodes((wxString const &)*arg1);
5241 wxPyEndAllowThreads(__tstate);
5242 if (PyErr_Occurred()) SWIG_fail;
5243 }
5244 {
5245 #if wxUSE_UNICODE
5246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5247 #else
5248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5249 #endif
5250 }
5251 {
5252 if (temp1)
5253 delete arg1;
5254 }
5255 return resultobj;
5256 fail:
5257 {
5258 if (temp1)
5259 delete arg1;
5260 }
5261 return NULL;
5262 }
5263
5264
5265 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5266 PyObject *resultobj = 0;
5267 wxString result;
5268
5269 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = wxGetEmailAddress();
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 {
5277 #if wxUSE_UNICODE
5278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5279 #else
5280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5281 #endif
5282 }
5283 return resultobj;
5284 fail:
5285 return NULL;
5286 }
5287
5288
5289 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5290 PyObject *resultobj = 0;
5291 wxString result;
5292
5293 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5294 {
5295 PyThreadState* __tstate = wxPyBeginAllowThreads();
5296 result = wxGetHostName();
5297 wxPyEndAllowThreads(__tstate);
5298 if (PyErr_Occurred()) SWIG_fail;
5299 }
5300 {
5301 #if wxUSE_UNICODE
5302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5303 #else
5304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5305 #endif
5306 }
5307 return resultobj;
5308 fail:
5309 return NULL;
5310 }
5311
5312
5313 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5314 PyObject *resultobj = 0;
5315 wxString result;
5316
5317 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5318 {
5319 PyThreadState* __tstate = wxPyBeginAllowThreads();
5320 result = wxGetFullHostName();
5321 wxPyEndAllowThreads(__tstate);
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 {
5325 #if wxUSE_UNICODE
5326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5327 #else
5328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5329 #endif
5330 }
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5338 PyObject *resultobj = 0;
5339 wxString result;
5340
5341 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5342 {
5343 PyThreadState* __tstate = wxPyBeginAllowThreads();
5344 result = wxGetUserId();
5345 wxPyEndAllowThreads(__tstate);
5346 if (PyErr_Occurred()) SWIG_fail;
5347 }
5348 {
5349 #if wxUSE_UNICODE
5350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5351 #else
5352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5353 #endif
5354 }
5355 return resultobj;
5356 fail:
5357 return NULL;
5358 }
5359
5360
5361 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5362 PyObject *resultobj = 0;
5363 wxString result;
5364
5365 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5366 {
5367 PyThreadState* __tstate = wxPyBeginAllowThreads();
5368 result = wxGetUserName();
5369 wxPyEndAllowThreads(__tstate);
5370 if (PyErr_Occurred()) SWIG_fail;
5371 }
5372 {
5373 #if wxUSE_UNICODE
5374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5375 #else
5376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5377 #endif
5378 }
5379 return resultobj;
5380 fail:
5381 return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5386 PyObject *resultobj = 0;
5387 wxString result;
5388
5389 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 result = wxGetHomeDir();
5393 wxPyEndAllowThreads(__tstate);
5394 if (PyErr_Occurred()) SWIG_fail;
5395 }
5396 {
5397 #if wxUSE_UNICODE
5398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5399 #else
5400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5401 #endif
5402 }
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5410 PyObject *resultobj = 0;
5411 wxString const &arg1_defvalue = wxPyEmptyString ;
5412 wxString *arg1 = (wxString *) &arg1_defvalue ;
5413 wxString result;
5414 bool temp1 = false ;
5415 PyObject * obj0 = 0 ;
5416 char * kwnames[] = {
5417 (char *) "user", NULL
5418 };
5419
5420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5421 if (obj0) {
5422 {
5423 arg1 = wxString_in_helper(obj0);
5424 if (arg1 == NULL) SWIG_fail;
5425 temp1 = true;
5426 }
5427 }
5428 {
5429 PyThreadState* __tstate = wxPyBeginAllowThreads();
5430 result = wxGetUserHome((wxString const &)*arg1);
5431 wxPyEndAllowThreads(__tstate);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 {
5435 #if wxUSE_UNICODE
5436 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5437 #else
5438 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5439 #endif
5440 }
5441 {
5442 if (temp1)
5443 delete arg1;
5444 }
5445 return resultobj;
5446 fail:
5447 {
5448 if (temp1)
5449 delete arg1;
5450 }
5451 return NULL;
5452 }
5453
5454
5455 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5456 PyObject *resultobj = 0;
5457 unsigned long result;
5458
5459 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 result = (unsigned long)wxGetProcessId();
5463 wxPyEndAllowThreads(__tstate);
5464 if (PyErr_Occurred()) SWIG_fail;
5465 }
5466 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5467 return resultobj;
5468 fail:
5469 return NULL;
5470 }
5471
5472
5473 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5474 PyObject *resultobj = 0;
5475
5476 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5477 {
5478 PyThreadState* __tstate = wxPyBeginAllowThreads();
5479 wxTrap();
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 resultobj = SWIG_Py_Void();
5484 return resultobj;
5485 fail:
5486 return NULL;
5487 }
5488
5489
5490 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5491 PyObject *resultobj = 0;
5492 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5493 wxString *arg1 = (wxString *) &arg1_defvalue ;
5494 wxString const &arg2_defvalue = wxPyEmptyString ;
5495 wxString *arg2 = (wxString *) &arg2_defvalue ;
5496 wxString const &arg3_defvalue = wxPyEmptyString ;
5497 wxString *arg3 = (wxString *) &arg3_defvalue ;
5498 wxString const &arg4_defvalue = wxPyEmptyString ;
5499 wxString *arg4 = (wxString *) &arg4_defvalue ;
5500 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5501 wxString *arg5 = (wxString *) &arg5_defvalue ;
5502 int arg6 = (int) 0 ;
5503 wxWindow *arg7 = (wxWindow *) NULL ;
5504 int arg8 = (int) -1 ;
5505 int arg9 = (int) -1 ;
5506 wxString result;
5507 bool temp1 = false ;
5508 bool temp2 = false ;
5509 bool temp3 = false ;
5510 bool temp4 = false ;
5511 bool temp5 = false ;
5512 int val6 ;
5513 int ecode6 = 0 ;
5514 void *argp7 = 0 ;
5515 int res7 = 0 ;
5516 int val8 ;
5517 int ecode8 = 0 ;
5518 int val9 ;
5519 int ecode9 = 0 ;
5520 PyObject * obj0 = 0 ;
5521 PyObject * obj1 = 0 ;
5522 PyObject * obj2 = 0 ;
5523 PyObject * obj3 = 0 ;
5524 PyObject * obj4 = 0 ;
5525 PyObject * obj5 = 0 ;
5526 PyObject * obj6 = 0 ;
5527 PyObject * obj7 = 0 ;
5528 PyObject * obj8 = 0 ;
5529 char * kwnames[] = {
5530 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5531 };
5532
5533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5534 if (obj0) {
5535 {
5536 arg1 = wxString_in_helper(obj0);
5537 if (arg1 == NULL) SWIG_fail;
5538 temp1 = true;
5539 }
5540 }
5541 if (obj1) {
5542 {
5543 arg2 = wxString_in_helper(obj1);
5544 if (arg2 == NULL) SWIG_fail;
5545 temp2 = true;
5546 }
5547 }
5548 if (obj2) {
5549 {
5550 arg3 = wxString_in_helper(obj2);
5551 if (arg3 == NULL) SWIG_fail;
5552 temp3 = true;
5553 }
5554 }
5555 if (obj3) {
5556 {
5557 arg4 = wxString_in_helper(obj3);
5558 if (arg4 == NULL) SWIG_fail;
5559 temp4 = true;
5560 }
5561 }
5562 if (obj4) {
5563 {
5564 arg5 = wxString_in_helper(obj4);
5565 if (arg5 == NULL) SWIG_fail;
5566 temp5 = true;
5567 }
5568 }
5569 if (obj5) {
5570 ecode6 = SWIG_AsVal_int(obj5, &val6);
5571 if (!SWIG_IsOK(ecode6)) {
5572 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5573 }
5574 arg6 = static_cast< int >(val6);
5575 }
5576 if (obj6) {
5577 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5578 if (!SWIG_IsOK(res7)) {
5579 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5580 }
5581 arg7 = reinterpret_cast< wxWindow * >(argp7);
5582 }
5583 if (obj7) {
5584 ecode8 = SWIG_AsVal_int(obj7, &val8);
5585 if (!SWIG_IsOK(ecode8)) {
5586 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5587 }
5588 arg8 = static_cast< int >(val8);
5589 }
5590 if (obj8) {
5591 ecode9 = SWIG_AsVal_int(obj8, &val9);
5592 if (!SWIG_IsOK(ecode9)) {
5593 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5594 }
5595 arg9 = static_cast< int >(val9);
5596 }
5597 {
5598 if (!wxPyCheckForApp()) SWIG_fail;
5599 PyThreadState* __tstate = wxPyBeginAllowThreads();
5600 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 {
5605 #if wxUSE_UNICODE
5606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5607 #else
5608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5609 #endif
5610 }
5611 {
5612 if (temp1)
5613 delete arg1;
5614 }
5615 {
5616 if (temp2)
5617 delete arg2;
5618 }
5619 {
5620 if (temp3)
5621 delete arg3;
5622 }
5623 {
5624 if (temp4)
5625 delete arg4;
5626 }
5627 {
5628 if (temp5)
5629 delete arg5;
5630 }
5631 return resultobj;
5632 fail:
5633 {
5634 if (temp1)
5635 delete arg1;
5636 }
5637 {
5638 if (temp2)
5639 delete arg2;
5640 }
5641 {
5642 if (temp3)
5643 delete arg3;
5644 }
5645 {
5646 if (temp4)
5647 delete arg4;
5648 }
5649 {
5650 if (temp5)
5651 delete arg5;
5652 }
5653 return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5658 PyObject *resultobj = 0;
5659 wxString *arg1 = 0 ;
5660 wxString *arg2 = 0 ;
5661 wxString const &arg3_defvalue = wxPyEmptyString ;
5662 wxString *arg3 = (wxString *) &arg3_defvalue ;
5663 wxWindow *arg4 = (wxWindow *) NULL ;
5664 wxString result;
5665 bool temp1 = false ;
5666 bool temp2 = false ;
5667 bool temp3 = false ;
5668 void *argp4 = 0 ;
5669 int res4 = 0 ;
5670 PyObject * obj0 = 0 ;
5671 PyObject * obj1 = 0 ;
5672 PyObject * obj2 = 0 ;
5673 PyObject * obj3 = 0 ;
5674 char * kwnames[] = {
5675 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5676 };
5677
5678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5679 {
5680 arg1 = wxString_in_helper(obj0);
5681 if (arg1 == NULL) SWIG_fail;
5682 temp1 = true;
5683 }
5684 {
5685 arg2 = wxString_in_helper(obj1);
5686 if (arg2 == NULL) SWIG_fail;
5687 temp2 = true;
5688 }
5689 if (obj2) {
5690 {
5691 arg3 = wxString_in_helper(obj2);
5692 if (arg3 == NULL) SWIG_fail;
5693 temp3 = true;
5694 }
5695 }
5696 if (obj3) {
5697 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5698 if (!SWIG_IsOK(res4)) {
5699 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5700 }
5701 arg4 = reinterpret_cast< wxWindow * >(argp4);
5702 }
5703 {
5704 if (!wxPyCheckForApp()) SWIG_fail;
5705 PyThreadState* __tstate = wxPyBeginAllowThreads();
5706 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5707 wxPyEndAllowThreads(__tstate);
5708 if (PyErr_Occurred()) SWIG_fail;
5709 }
5710 {
5711 #if wxUSE_UNICODE
5712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5713 #else
5714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5715 #endif
5716 }
5717 {
5718 if (temp1)
5719 delete arg1;
5720 }
5721 {
5722 if (temp2)
5723 delete arg2;
5724 }
5725 {
5726 if (temp3)
5727 delete arg3;
5728 }
5729 return resultobj;
5730 fail:
5731 {
5732 if (temp1)
5733 delete arg1;
5734 }
5735 {
5736 if (temp2)
5737 delete arg2;
5738 }
5739 {
5740 if (temp3)
5741 delete arg3;
5742 }
5743 return NULL;
5744 }
5745
5746
5747 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj = 0;
5749 wxString *arg1 = 0 ;
5750 wxString *arg2 = 0 ;
5751 wxString const &arg3_defvalue = wxPyEmptyString ;
5752 wxString *arg3 = (wxString *) &arg3_defvalue ;
5753 wxWindow *arg4 = (wxWindow *) NULL ;
5754 wxString result;
5755 bool temp1 = false ;
5756 bool temp2 = false ;
5757 bool temp3 = false ;
5758 void *argp4 = 0 ;
5759 int res4 = 0 ;
5760 PyObject * obj0 = 0 ;
5761 PyObject * obj1 = 0 ;
5762 PyObject * obj2 = 0 ;
5763 PyObject * obj3 = 0 ;
5764 char * kwnames[] = {
5765 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5766 };
5767
5768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5769 {
5770 arg1 = wxString_in_helper(obj0);
5771 if (arg1 == NULL) SWIG_fail;
5772 temp1 = true;
5773 }
5774 {
5775 arg2 = wxString_in_helper(obj1);
5776 if (arg2 == NULL) SWIG_fail;
5777 temp2 = true;
5778 }
5779 if (obj2) {
5780 {
5781 arg3 = wxString_in_helper(obj2);
5782 if (arg3 == NULL) SWIG_fail;
5783 temp3 = true;
5784 }
5785 }
5786 if (obj3) {
5787 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5788 if (!SWIG_IsOK(res4)) {
5789 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5790 }
5791 arg4 = reinterpret_cast< wxWindow * >(argp4);
5792 }
5793 {
5794 if (!wxPyCheckForApp()) SWIG_fail;
5795 PyThreadState* __tstate = wxPyBeginAllowThreads();
5796 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5797 wxPyEndAllowThreads(__tstate);
5798 if (PyErr_Occurred()) SWIG_fail;
5799 }
5800 {
5801 #if wxUSE_UNICODE
5802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5803 #else
5804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5805 #endif
5806 }
5807 {
5808 if (temp1)
5809 delete arg1;
5810 }
5811 {
5812 if (temp2)
5813 delete arg2;
5814 }
5815 {
5816 if (temp3)
5817 delete arg3;
5818 }
5819 return resultobj;
5820 fail:
5821 {
5822 if (temp1)
5823 delete arg1;
5824 }
5825 {
5826 if (temp2)
5827 delete arg2;
5828 }
5829 {
5830 if (temp3)
5831 delete arg3;
5832 }
5833 return NULL;
5834 }
5835
5836
5837 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5838 PyObject *resultobj = 0;
5839 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5840 wxString *arg1 = (wxString *) &arg1_defvalue ;
5841 wxString const &arg2_defvalue = wxPyEmptyString ;
5842 wxString *arg2 = (wxString *) &arg2_defvalue ;
5843 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5844 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5845 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5846 wxWindow *arg5 = (wxWindow *) NULL ;
5847 wxString result;
5848 bool temp1 = false ;
5849 bool temp2 = false ;
5850 long val3 ;
5851 int ecode3 = 0 ;
5852 wxPoint temp4 ;
5853 void *argp5 = 0 ;
5854 int res5 = 0 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 PyObject * obj2 = 0 ;
5858 PyObject * obj3 = 0 ;
5859 PyObject * obj4 = 0 ;
5860 char * kwnames[] = {
5861 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5862 };
5863
5864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5865 if (obj0) {
5866 {
5867 arg1 = wxString_in_helper(obj0);
5868 if (arg1 == NULL) SWIG_fail;
5869 temp1 = true;
5870 }
5871 }
5872 if (obj1) {
5873 {
5874 arg2 = wxString_in_helper(obj1);
5875 if (arg2 == NULL) SWIG_fail;
5876 temp2 = true;
5877 }
5878 }
5879 if (obj2) {
5880 ecode3 = SWIG_AsVal_long(obj2, &val3);
5881 if (!SWIG_IsOK(ecode3)) {
5882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5883 }
5884 arg3 = static_cast< long >(val3);
5885 }
5886 if (obj3) {
5887 {
5888 arg4 = &temp4;
5889 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5890 }
5891 }
5892 if (obj4) {
5893 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5894 if (!SWIG_IsOK(res5)) {
5895 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5896 }
5897 arg5 = reinterpret_cast< wxWindow * >(argp5);
5898 }
5899 {
5900 if (!wxPyCheckForApp()) SWIG_fail;
5901 PyThreadState* __tstate = wxPyBeginAllowThreads();
5902 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5903 wxPyEndAllowThreads(__tstate);
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 {
5907 #if wxUSE_UNICODE
5908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5909 #else
5910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5911 #endif
5912 }
5913 {
5914 if (temp1)
5915 delete arg1;
5916 }
5917 {
5918 if (temp2)
5919 delete arg2;
5920 }
5921 return resultobj;
5922 fail:
5923 {
5924 if (temp1)
5925 delete arg1;
5926 }
5927 {
5928 if (temp2)
5929 delete arg2;
5930 }
5931 return NULL;
5932 }
5933
5934
5935 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5936 PyObject *resultobj = 0;
5937 wxString *arg1 = 0 ;
5938 wxString const &arg2_defvalue = wxPyEmptyString ;
5939 wxString *arg2 = (wxString *) &arg2_defvalue ;
5940 wxString const &arg3_defvalue = wxPyEmptyString ;
5941 wxString *arg3 = (wxString *) &arg3_defvalue ;
5942 wxWindow *arg4 = (wxWindow *) NULL ;
5943 int arg5 = (int) -1 ;
5944 int arg6 = (int) -1 ;
5945 bool arg7 = (bool) true ;
5946 wxString result;
5947 bool temp1 = false ;
5948 bool temp2 = false ;
5949 bool temp3 = false ;
5950 void *argp4 = 0 ;
5951 int res4 = 0 ;
5952 int val5 ;
5953 int ecode5 = 0 ;
5954 int val6 ;
5955 int ecode6 = 0 ;
5956 bool val7 ;
5957 int ecode7 = 0 ;
5958 PyObject * obj0 = 0 ;
5959 PyObject * obj1 = 0 ;
5960 PyObject * obj2 = 0 ;
5961 PyObject * obj3 = 0 ;
5962 PyObject * obj4 = 0 ;
5963 PyObject * obj5 = 0 ;
5964 PyObject * obj6 = 0 ;
5965 char * kwnames[] = {
5966 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5967 };
5968
5969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5970 {
5971 arg1 = wxString_in_helper(obj0);
5972 if (arg1 == NULL) SWIG_fail;
5973 temp1 = true;
5974 }
5975 if (obj1) {
5976 {
5977 arg2 = wxString_in_helper(obj1);
5978 if (arg2 == NULL) SWIG_fail;
5979 temp2 = true;
5980 }
5981 }
5982 if (obj2) {
5983 {
5984 arg3 = wxString_in_helper(obj2);
5985 if (arg3 == NULL) SWIG_fail;
5986 temp3 = true;
5987 }
5988 }
5989 if (obj3) {
5990 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5991 if (!SWIG_IsOK(res4)) {
5992 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
5993 }
5994 arg4 = reinterpret_cast< wxWindow * >(argp4);
5995 }
5996 if (obj4) {
5997 ecode5 = SWIG_AsVal_int(obj4, &val5);
5998 if (!SWIG_IsOK(ecode5)) {
5999 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6000 }
6001 arg5 = static_cast< int >(val5);
6002 }
6003 if (obj5) {
6004 ecode6 = SWIG_AsVal_int(obj5, &val6);
6005 if (!SWIG_IsOK(ecode6)) {
6006 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6007 }
6008 arg6 = static_cast< int >(val6);
6009 }
6010 if (obj6) {
6011 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6012 if (!SWIG_IsOK(ecode7)) {
6013 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6014 }
6015 arg7 = static_cast< bool >(val7);
6016 }
6017 {
6018 if (!wxPyCheckForApp()) SWIG_fail;
6019 PyThreadState* __tstate = wxPyBeginAllowThreads();
6020 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6021 wxPyEndAllowThreads(__tstate);
6022 if (PyErr_Occurred()) SWIG_fail;
6023 }
6024 {
6025 #if wxUSE_UNICODE
6026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6027 #else
6028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6029 #endif
6030 }
6031 {
6032 if (temp1)
6033 delete arg1;
6034 }
6035 {
6036 if (temp2)
6037 delete arg2;
6038 }
6039 {
6040 if (temp3)
6041 delete arg3;
6042 }
6043 return resultobj;
6044 fail:
6045 {
6046 if (temp1)
6047 delete arg1;
6048 }
6049 {
6050 if (temp2)
6051 delete arg2;
6052 }
6053 {
6054 if (temp3)
6055 delete arg3;
6056 }
6057 return NULL;
6058 }
6059
6060
6061 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6062 PyObject *resultobj = 0;
6063 wxString *arg1 = 0 ;
6064 wxString const &arg2_defvalue = wxPyEmptyString ;
6065 wxString *arg2 = (wxString *) &arg2_defvalue ;
6066 wxString const &arg3_defvalue = wxPyEmptyString ;
6067 wxString *arg3 = (wxString *) &arg3_defvalue ;
6068 wxWindow *arg4 = (wxWindow *) NULL ;
6069 wxString result;
6070 bool temp1 = false ;
6071 bool temp2 = false ;
6072 bool temp3 = false ;
6073 void *argp4 = 0 ;
6074 int res4 = 0 ;
6075 PyObject * obj0 = 0 ;
6076 PyObject * obj1 = 0 ;
6077 PyObject * obj2 = 0 ;
6078 PyObject * obj3 = 0 ;
6079 char * kwnames[] = {
6080 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6081 };
6082
6083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6084 {
6085 arg1 = wxString_in_helper(obj0);
6086 if (arg1 == NULL) SWIG_fail;
6087 temp1 = true;
6088 }
6089 if (obj1) {
6090 {
6091 arg2 = wxString_in_helper(obj1);
6092 if (arg2 == NULL) SWIG_fail;
6093 temp2 = true;
6094 }
6095 }
6096 if (obj2) {
6097 {
6098 arg3 = wxString_in_helper(obj2);
6099 if (arg3 == NULL) SWIG_fail;
6100 temp3 = true;
6101 }
6102 }
6103 if (obj3) {
6104 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6105 if (!SWIG_IsOK(res4)) {
6106 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6107 }
6108 arg4 = reinterpret_cast< wxWindow * >(argp4);
6109 }
6110 {
6111 if (!wxPyCheckForApp()) SWIG_fail;
6112 PyThreadState* __tstate = wxPyBeginAllowThreads();
6113 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6114 wxPyEndAllowThreads(__tstate);
6115 if (PyErr_Occurred()) SWIG_fail;
6116 }
6117 {
6118 #if wxUSE_UNICODE
6119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6120 #else
6121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6122 #endif
6123 }
6124 {
6125 if (temp1)
6126 delete arg1;
6127 }
6128 {
6129 if (temp2)
6130 delete arg2;
6131 }
6132 {
6133 if (temp3)
6134 delete arg3;
6135 }
6136 return resultobj;
6137 fail:
6138 {
6139 if (temp1)
6140 delete arg1;
6141 }
6142 {
6143 if (temp2)
6144 delete arg2;
6145 }
6146 {
6147 if (temp3)
6148 delete arg3;
6149 }
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6155 PyObject *resultobj = 0;
6156 wxString *arg1 = 0 ;
6157 wxString *arg2 = 0 ;
6158 int arg3 ;
6159 wxString *arg4 = (wxString *) 0 ;
6160 wxWindow *arg5 = (wxWindow *) NULL ;
6161 int arg6 = (int) -1 ;
6162 int arg7 = (int) -1 ;
6163 bool arg8 = (bool) true ;
6164 int arg9 = (int) 150 ;
6165 int arg10 = (int) 200 ;
6166 wxString result;
6167 bool temp1 = false ;
6168 bool temp2 = false ;
6169 void *argp5 = 0 ;
6170 int res5 = 0 ;
6171 int val6 ;
6172 int ecode6 = 0 ;
6173 int val7 ;
6174 int ecode7 = 0 ;
6175 bool val8 ;
6176 int ecode8 = 0 ;
6177 int val9 ;
6178 int ecode9 = 0 ;
6179 int val10 ;
6180 int ecode10 = 0 ;
6181 PyObject * obj0 = 0 ;
6182 PyObject * obj1 = 0 ;
6183 PyObject * obj2 = 0 ;
6184 PyObject * obj3 = 0 ;
6185 PyObject * obj4 = 0 ;
6186 PyObject * obj5 = 0 ;
6187 PyObject * obj6 = 0 ;
6188 PyObject * obj7 = 0 ;
6189 PyObject * obj8 = 0 ;
6190 char * kwnames[] = {
6191 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6192 };
6193
6194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6195 {
6196 arg1 = wxString_in_helper(obj0);
6197 if (arg1 == NULL) SWIG_fail;
6198 temp1 = true;
6199 }
6200 {
6201 arg2 = wxString_in_helper(obj1);
6202 if (arg2 == NULL) SWIG_fail;
6203 temp2 = true;
6204 }
6205 {
6206 arg3 = PyList_Size(obj2);
6207 arg4 = wxString_LIST_helper(obj2);
6208 if (arg4 == NULL) SWIG_fail;
6209 }
6210 if (obj3) {
6211 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6212 if (!SWIG_IsOK(res5)) {
6213 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6214 }
6215 arg5 = reinterpret_cast< wxWindow * >(argp5);
6216 }
6217 if (obj4) {
6218 ecode6 = SWIG_AsVal_int(obj4, &val6);
6219 if (!SWIG_IsOK(ecode6)) {
6220 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6221 }
6222 arg6 = static_cast< int >(val6);
6223 }
6224 if (obj5) {
6225 ecode7 = SWIG_AsVal_int(obj5, &val7);
6226 if (!SWIG_IsOK(ecode7)) {
6227 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6228 }
6229 arg7 = static_cast< int >(val7);
6230 }
6231 if (obj6) {
6232 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6233 if (!SWIG_IsOK(ecode8)) {
6234 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6235 }
6236 arg8 = static_cast< bool >(val8);
6237 }
6238 if (obj7) {
6239 ecode9 = SWIG_AsVal_int(obj7, &val9);
6240 if (!SWIG_IsOK(ecode9)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6242 }
6243 arg9 = static_cast< int >(val9);
6244 }
6245 if (obj8) {
6246 ecode10 = SWIG_AsVal_int(obj8, &val10);
6247 if (!SWIG_IsOK(ecode10)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6249 }
6250 arg10 = static_cast< int >(val10);
6251 }
6252 {
6253 if (!wxPyCheckForApp()) SWIG_fail;
6254 PyThreadState* __tstate = wxPyBeginAllowThreads();
6255 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6256 wxPyEndAllowThreads(__tstate);
6257 if (PyErr_Occurred()) SWIG_fail;
6258 }
6259 {
6260 #if wxUSE_UNICODE
6261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6262 #else
6263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6264 #endif
6265 }
6266 {
6267 if (temp1)
6268 delete arg1;
6269 }
6270 {
6271 if (temp2)
6272 delete arg2;
6273 }
6274 {
6275 if (arg4) delete [] arg4;
6276 }
6277 return resultobj;
6278 fail:
6279 {
6280 if (temp1)
6281 delete arg1;
6282 }
6283 {
6284 if (temp2)
6285 delete arg2;
6286 }
6287 {
6288 if (arg4) delete [] arg4;
6289 }
6290 return NULL;
6291 }
6292
6293
6294 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6295 PyObject *resultobj = 0;
6296 wxString *arg1 = 0 ;
6297 wxString *arg2 = 0 ;
6298 int arg3 ;
6299 wxString *arg4 = (wxString *) 0 ;
6300 wxWindow *arg5 = (wxWindow *) NULL ;
6301 int arg6 = (int) -1 ;
6302 int arg7 = (int) -1 ;
6303 bool arg8 = (bool) true ;
6304 int arg9 = (int) 150 ;
6305 int arg10 = (int) 200 ;
6306 int result;
6307 bool temp1 = false ;
6308 bool temp2 = false ;
6309 void *argp5 = 0 ;
6310 int res5 = 0 ;
6311 int val6 ;
6312 int ecode6 = 0 ;
6313 int val7 ;
6314 int ecode7 = 0 ;
6315 bool val8 ;
6316 int ecode8 = 0 ;
6317 int val9 ;
6318 int ecode9 = 0 ;
6319 int val10 ;
6320 int ecode10 = 0 ;
6321 PyObject * obj0 = 0 ;
6322 PyObject * obj1 = 0 ;
6323 PyObject * obj2 = 0 ;
6324 PyObject * obj3 = 0 ;
6325 PyObject * obj4 = 0 ;
6326 PyObject * obj5 = 0 ;
6327 PyObject * obj6 = 0 ;
6328 PyObject * obj7 = 0 ;
6329 PyObject * obj8 = 0 ;
6330 char * kwnames[] = {
6331 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6332 };
6333
6334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6335 {
6336 arg1 = wxString_in_helper(obj0);
6337 if (arg1 == NULL) SWIG_fail;
6338 temp1 = true;
6339 }
6340 {
6341 arg2 = wxString_in_helper(obj1);
6342 if (arg2 == NULL) SWIG_fail;
6343 temp2 = true;
6344 }
6345 {
6346 arg3 = PyList_Size(obj2);
6347 arg4 = wxString_LIST_helper(obj2);
6348 if (arg4 == NULL) SWIG_fail;
6349 }
6350 if (obj3) {
6351 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6352 if (!SWIG_IsOK(res5)) {
6353 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6354 }
6355 arg5 = reinterpret_cast< wxWindow * >(argp5);
6356 }
6357 if (obj4) {
6358 ecode6 = SWIG_AsVal_int(obj4, &val6);
6359 if (!SWIG_IsOK(ecode6)) {
6360 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6361 }
6362 arg6 = static_cast< int >(val6);
6363 }
6364 if (obj5) {
6365 ecode7 = SWIG_AsVal_int(obj5, &val7);
6366 if (!SWIG_IsOK(ecode7)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6368 }
6369 arg7 = static_cast< int >(val7);
6370 }
6371 if (obj6) {
6372 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6373 if (!SWIG_IsOK(ecode8)) {
6374 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6375 }
6376 arg8 = static_cast< bool >(val8);
6377 }
6378 if (obj7) {
6379 ecode9 = SWIG_AsVal_int(obj7, &val9);
6380 if (!SWIG_IsOK(ecode9)) {
6381 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6382 }
6383 arg9 = static_cast< int >(val9);
6384 }
6385 if (obj8) {
6386 ecode10 = SWIG_AsVal_int(obj8, &val10);
6387 if (!SWIG_IsOK(ecode10)) {
6388 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6389 }
6390 arg10 = static_cast< int >(val10);
6391 }
6392 {
6393 if (!wxPyCheckForApp()) SWIG_fail;
6394 PyThreadState* __tstate = wxPyBeginAllowThreads();
6395 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6396 wxPyEndAllowThreads(__tstate);
6397 if (PyErr_Occurred()) SWIG_fail;
6398 }
6399 resultobj = SWIG_From_int(static_cast< int >(result));
6400 {
6401 if (temp1)
6402 delete arg1;
6403 }
6404 {
6405 if (temp2)
6406 delete arg2;
6407 }
6408 {
6409 if (arg4) delete [] arg4;
6410 }
6411 return resultobj;
6412 fail:
6413 {
6414 if (temp1)
6415 delete arg1;
6416 }
6417 {
6418 if (temp2)
6419 delete arg2;
6420 }
6421 {
6422 if (arg4) delete [] arg4;
6423 }
6424 return NULL;
6425 }
6426
6427
6428 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6429 PyObject *resultobj = 0;
6430 wxString *arg1 = 0 ;
6431 wxString const &arg2_defvalue = wxPyEmptyString ;
6432 wxString *arg2 = (wxString *) &arg2_defvalue ;
6433 int arg3 = (int) wxOK|wxCENTRE ;
6434 wxWindow *arg4 = (wxWindow *) NULL ;
6435 int arg5 = (int) -1 ;
6436 int arg6 = (int) -1 ;
6437 int result;
6438 bool temp1 = false ;
6439 bool temp2 = false ;
6440 int val3 ;
6441 int ecode3 = 0 ;
6442 void *argp4 = 0 ;
6443 int res4 = 0 ;
6444 int val5 ;
6445 int ecode5 = 0 ;
6446 int val6 ;
6447 int ecode6 = 0 ;
6448 PyObject * obj0 = 0 ;
6449 PyObject * obj1 = 0 ;
6450 PyObject * obj2 = 0 ;
6451 PyObject * obj3 = 0 ;
6452 PyObject * obj4 = 0 ;
6453 PyObject * obj5 = 0 ;
6454 char * kwnames[] = {
6455 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6456 };
6457
6458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6459 {
6460 arg1 = wxString_in_helper(obj0);
6461 if (arg1 == NULL) SWIG_fail;
6462 temp1 = true;
6463 }
6464 if (obj1) {
6465 {
6466 arg2 = wxString_in_helper(obj1);
6467 if (arg2 == NULL) SWIG_fail;
6468 temp2 = true;
6469 }
6470 }
6471 if (obj2) {
6472 ecode3 = SWIG_AsVal_int(obj2, &val3);
6473 if (!SWIG_IsOK(ecode3)) {
6474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6475 }
6476 arg3 = static_cast< int >(val3);
6477 }
6478 if (obj3) {
6479 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6480 if (!SWIG_IsOK(res4)) {
6481 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6482 }
6483 arg4 = reinterpret_cast< wxWindow * >(argp4);
6484 }
6485 if (obj4) {
6486 ecode5 = SWIG_AsVal_int(obj4, &val5);
6487 if (!SWIG_IsOK(ecode5)) {
6488 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6489 }
6490 arg5 = static_cast< int >(val5);
6491 }
6492 if (obj5) {
6493 ecode6 = SWIG_AsVal_int(obj5, &val6);
6494 if (!SWIG_IsOK(ecode6)) {
6495 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6496 }
6497 arg6 = static_cast< int >(val6);
6498 }
6499 {
6500 if (!wxPyCheckForApp()) SWIG_fail;
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6503 wxPyEndAllowThreads(__tstate);
6504 if (PyErr_Occurred()) SWIG_fail;
6505 }
6506 resultobj = SWIG_From_int(static_cast< int >(result));
6507 {
6508 if (temp1)
6509 delete arg1;
6510 }
6511 {
6512 if (temp2)
6513 delete arg2;
6514 }
6515 return resultobj;
6516 fail:
6517 {
6518 if (temp1)
6519 delete arg1;
6520 }
6521 {
6522 if (temp2)
6523 delete arg2;
6524 }
6525 return NULL;
6526 }
6527
6528
6529 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6530 PyObject *resultobj = 0;
6531 bool result;
6532
6533 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6534 {
6535 if (!wxPyCheckForApp()) SWIG_fail;
6536 PyThreadState* __tstate = wxPyBeginAllowThreads();
6537 result = (bool)wxColourDisplay();
6538 wxPyEndAllowThreads(__tstate);
6539 if (PyErr_Occurred()) SWIG_fail;
6540 }
6541 {
6542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6543 }
6544 return resultobj;
6545 fail:
6546 return NULL;
6547 }
6548
6549
6550 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6551 PyObject *resultobj = 0;
6552 int result;
6553
6554 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6555 {
6556 if (!wxPyCheckForApp()) SWIG_fail;
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = (int)wxDisplayDepth();
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_From_int(static_cast< int >(result));
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6570 PyObject *resultobj = 0;
6571 int result;
6572
6573 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6574 {
6575 if (!wxPyCheckForApp()) SWIG_fail;
6576 PyThreadState* __tstate = wxPyBeginAllowThreads();
6577 result = (int)wxGetDisplayDepth();
6578 wxPyEndAllowThreads(__tstate);
6579 if (PyErr_Occurred()) SWIG_fail;
6580 }
6581 resultobj = SWIG_From_int(static_cast< int >(result));
6582 return resultobj;
6583 fail:
6584 return NULL;
6585 }
6586
6587
6588 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6589 PyObject *resultobj = 0;
6590 int *arg1 = (int *) 0 ;
6591 int *arg2 = (int *) 0 ;
6592 int temp1 ;
6593 int res1 = SWIG_TMPOBJ ;
6594 int temp2 ;
6595 int res2 = SWIG_TMPOBJ ;
6596
6597 arg1 = &temp1;
6598 arg2 = &temp2;
6599 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6600 {
6601 if (!wxPyCheckForApp()) SWIG_fail;
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 wxDisplaySize(arg1,arg2);
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 resultobj = SWIG_Py_Void();
6608 if (SWIG_IsTmpObj(res1)) {
6609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6610 } else {
6611 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6613 }
6614 if (SWIG_IsTmpObj(res2)) {
6615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6616 } else {
6617 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6619 }
6620 return resultobj;
6621 fail:
6622 return NULL;
6623 }
6624
6625
6626 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6627 PyObject *resultobj = 0;
6628 wxSize result;
6629
6630 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6631 {
6632 if (!wxPyCheckForApp()) SWIG_fail;
6633 PyThreadState* __tstate = wxPyBeginAllowThreads();
6634 result = wxGetDisplaySize();
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6646 PyObject *resultobj = 0;
6647 int *arg1 = (int *) 0 ;
6648 int *arg2 = (int *) 0 ;
6649 int temp1 ;
6650 int res1 = SWIG_TMPOBJ ;
6651 int temp2 ;
6652 int res2 = SWIG_TMPOBJ ;
6653
6654 arg1 = &temp1;
6655 arg2 = &temp2;
6656 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6657 {
6658 if (!wxPyCheckForApp()) SWIG_fail;
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 wxDisplaySizeMM(arg1,arg2);
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 resultobj = SWIG_Py_Void();
6665 if (SWIG_IsTmpObj(res1)) {
6666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6667 } else {
6668 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6670 }
6671 if (SWIG_IsTmpObj(res2)) {
6672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6673 } else {
6674 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6676 }
6677 return resultobj;
6678 fail:
6679 return NULL;
6680 }
6681
6682
6683 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6684 PyObject *resultobj = 0;
6685 wxSize result;
6686
6687 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6688 {
6689 if (!wxPyCheckForApp()) SWIG_fail;
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 result = wxGetDisplaySizeMM();
6692 wxPyEndAllowThreads(__tstate);
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6696 return resultobj;
6697 fail:
6698 return NULL;
6699 }
6700
6701
6702 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6703 PyObject *resultobj = 0;
6704 int *arg1 = (int *) 0 ;
6705 int *arg2 = (int *) 0 ;
6706 int *arg3 = (int *) 0 ;
6707 int *arg4 = (int *) 0 ;
6708 int temp1 ;
6709 int res1 = SWIG_TMPOBJ ;
6710 int temp2 ;
6711 int res2 = SWIG_TMPOBJ ;
6712 int temp3 ;
6713 int res3 = SWIG_TMPOBJ ;
6714 int temp4 ;
6715 int res4 = SWIG_TMPOBJ ;
6716
6717 arg1 = &temp1;
6718 arg2 = &temp2;
6719 arg3 = &temp3;
6720 arg4 = &temp4;
6721 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6722 {
6723 if (!wxPyCheckForApp()) SWIG_fail;
6724 PyThreadState* __tstate = wxPyBeginAllowThreads();
6725 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6726 wxPyEndAllowThreads(__tstate);
6727 if (PyErr_Occurred()) SWIG_fail;
6728 }
6729 resultobj = SWIG_Py_Void();
6730 if (SWIG_IsTmpObj(res1)) {
6731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6732 } else {
6733 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6735 }
6736 if (SWIG_IsTmpObj(res2)) {
6737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6738 } else {
6739 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6741 }
6742 if (SWIG_IsTmpObj(res3)) {
6743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6744 } else {
6745 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6747 }
6748 if (SWIG_IsTmpObj(res4)) {
6749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6750 } else {
6751 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6753 }
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 wxRect result;
6763
6764 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6765 {
6766 if (!wxPyCheckForApp()) SWIG_fail;
6767 PyThreadState* __tstate = wxPyBeginAllowThreads();
6768 result = wxGetClientDisplayRect();
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6780 PyObject *resultobj = 0;
6781 wxCursor *arg1 = 0 ;
6782 void *argp1 = 0 ;
6783 int res1 = 0 ;
6784 PyObject * obj0 = 0 ;
6785 char * kwnames[] = {
6786 (char *) "cursor", NULL
6787 };
6788
6789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6790 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6793 }
6794 if (!argp1) {
6795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6796 }
6797 arg1 = reinterpret_cast< wxCursor * >(argp1);
6798 {
6799 if (!wxPyCheckForApp()) SWIG_fail;
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 wxSetCursor(*arg1);
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_Py_Void();
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 void *result = 0 ;
6815
6816 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6817 {
6818 if (!wxPyCheckForApp()) SWIG_fail;
6819 PyThreadState* __tstate = wxPyBeginAllowThreads();
6820 result = (void *)wxGetXDisplay();
6821 wxPyEndAllowThreads(__tstate);
6822 if (PyErr_Occurred()) SWIG_fail;
6823 }
6824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6825 return resultobj;
6826 fail:
6827 return NULL;
6828 }
6829
6830
6831 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6832 PyObject *resultobj = 0;
6833 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6834 void *argp1 = 0 ;
6835 int res1 = 0 ;
6836 PyObject * obj0 = 0 ;
6837 char * kwnames[] = {
6838 (char *) "cursor", NULL
6839 };
6840
6841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6842 if (obj0) {
6843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6844 if (!SWIG_IsOK(res1)) {
6845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6846 }
6847 arg1 = reinterpret_cast< wxCursor * >(argp1);
6848 }
6849 {
6850 if (!wxPyCheckForApp()) SWIG_fail;
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 wxBeginBusyCursor(arg1);
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_Py_Void();
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6864 PyObject *resultobj = 0;
6865 wxPoint result;
6866
6867 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6868 {
6869 if (!wxPyCheckForApp()) SWIG_fail;
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 result = wxGetMousePosition();
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6883 PyObject *resultobj = 0;
6884 wxWindow *result = 0 ;
6885
6886 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6887 {
6888 if (!wxPyCheckForApp()) SWIG_fail;
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 result = (wxWindow *)FindWindowAtPointer();
6891 wxPyEndAllowThreads(__tstate);
6892 if (PyErr_Occurred()) SWIG_fail;
6893 }
6894 {
6895 resultobj = wxPyMake_wxObject(result, 0);
6896 }
6897 return resultobj;
6898 fail:
6899 return NULL;
6900 }
6901
6902
6903 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6904 PyObject *resultobj = 0;
6905 wxWindow *result = 0 ;
6906
6907 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6908 {
6909 if (!wxPyCheckForApp()) SWIG_fail;
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 result = (wxWindow *)wxGetActiveWindow();
6912 wxPyEndAllowThreads(__tstate);
6913 if (PyErr_Occurred()) SWIG_fail;
6914 }
6915 {
6916 resultobj = wxPyMake_wxObject(result, 0);
6917 }
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6925 PyObject *resultobj = 0;
6926 wxPoint *arg1 = 0 ;
6927 wxWindow *result = 0 ;
6928 wxPoint temp1 ;
6929 PyObject * obj0 = 0 ;
6930 char * kwnames[] = {
6931 (char *) "pt", NULL
6932 };
6933
6934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6935 {
6936 arg1 = &temp1;
6937 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6938 }
6939 {
6940 if (!wxPyCheckForApp()) SWIG_fail;
6941 PyThreadState* __tstate = wxPyBeginAllowThreads();
6942 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 {
6947 resultobj = wxPyMake_wxObject(result, 0);
6948 }
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj = 0;
6957 wxPoint *arg1 = 0 ;
6958 wxWindow *result = 0 ;
6959 wxPoint temp1 ;
6960 PyObject * obj0 = 0 ;
6961 char * kwnames[] = {
6962 (char *) "pt", NULL
6963 };
6964
6965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6966 {
6967 arg1 = &temp1;
6968 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6969 }
6970 {
6971 if (!wxPyCheckForApp()) SWIG_fail;
6972 PyThreadState* __tstate = wxPyBeginAllowThreads();
6973 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6974 wxPyEndAllowThreads(__tstate);
6975 if (PyErr_Occurred()) SWIG_fail;
6976 }
6977 {
6978 resultobj = wxPyMake_wxObject(result, 0);
6979 }
6980 return resultobj;
6981 fail:
6982 return NULL;
6983 }
6984
6985
6986 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6987 PyObject *resultobj = 0;
6988 wxWindow *arg1 = (wxWindow *) 0 ;
6989 wxWindow *result = 0 ;
6990 void *argp1 = 0 ;
6991 int res1 = 0 ;
6992 PyObject * obj0 = 0 ;
6993 char * kwnames[] = {
6994 (char *) "win", NULL
6995 };
6996
6997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
6998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
6999 if (!SWIG_IsOK(res1)) {
7000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7001 }
7002 arg1 = reinterpret_cast< wxWindow * >(argp1);
7003 {
7004 if (!wxPyCheckForApp()) SWIG_fail;
7005 PyThreadState* __tstate = wxPyBeginAllowThreads();
7006 result = (wxWindow *)wxGetTopLevelParent(arg1);
7007 wxPyEndAllowThreads(__tstate);
7008 if (PyErr_Occurred()) SWIG_fail;
7009 }
7010 {
7011 resultobj = wxPyMake_wxObject(result, 0);
7012 }
7013 return resultobj;
7014 fail:
7015 return NULL;
7016 }
7017
7018
7019 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7020 PyObject *resultobj = 0;
7021 wxString *arg1 = 0 ;
7022 bool result;
7023 bool temp1 = false ;
7024 PyObject * obj0 = 0 ;
7025 char * kwnames[] = {
7026 (char *) "url", NULL
7027 };
7028
7029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7030 {
7031 arg1 = wxString_in_helper(obj0);
7032 if (arg1 == NULL) SWIG_fail;
7033 temp1 = true;
7034 }
7035 {
7036 PyThreadState* __tstate = wxPyBeginAllowThreads();
7037 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 {
7042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7043 }
7044 {
7045 if (temp1)
7046 delete arg1;
7047 }
7048 return resultobj;
7049 fail:
7050 {
7051 if (temp1)
7052 delete arg1;
7053 }
7054 return NULL;
7055 }
7056
7057
7058 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7059 PyObject *resultobj = 0;
7060 wxKeyCode arg1 ;
7061 bool result;
7062 int val1 ;
7063 int ecode1 = 0 ;
7064 PyObject * obj0 = 0 ;
7065 char * kwnames[] = {
7066 (char *) "key", NULL
7067 };
7068
7069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7070 ecode1 = SWIG_AsVal_int(obj0, &val1);
7071 if (!SWIG_IsOK(ecode1)) {
7072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7073 }
7074 arg1 = static_cast< wxKeyCode >(val1);
7075 {
7076 if (!wxPyCheckForApp()) SWIG_fail;
7077 PyThreadState* __tstate = wxPyBeginAllowThreads();
7078 result = (bool)wxGetKeyState(arg1);
7079 wxPyEndAllowThreads(__tstate);
7080 if (PyErr_Occurred()) SWIG_fail;
7081 }
7082 {
7083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7084 }
7085 return resultobj;
7086 fail:
7087 return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7092 PyObject *resultobj = 0;
7093 wxMouseState *result = 0 ;
7094
7095 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7096 {
7097 PyThreadState* __tstate = wxPyBeginAllowThreads();
7098 result = (wxMouseState *)new wxMouseState();
7099 wxPyEndAllowThreads(__tstate);
7100 if (PyErr_Occurred()) SWIG_fail;
7101 }
7102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7110 PyObject *resultobj = 0;
7111 wxMouseState *arg1 = (wxMouseState *) 0 ;
7112 void *argp1 = 0 ;
7113 int res1 = 0 ;
7114 PyObject *swig_obj[1] ;
7115
7116 if (!args) SWIG_fail;
7117 swig_obj[0] = args;
7118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7119 if (!SWIG_IsOK(res1)) {
7120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7121 }
7122 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 delete arg1;
7126
7127 wxPyEndAllowThreads(__tstate);
7128 if (PyErr_Occurred()) SWIG_fail;
7129 }
7130 resultobj = SWIG_Py_Void();
7131 return resultobj;
7132 fail:
7133 return NULL;
7134 }
7135
7136
7137 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7138 PyObject *resultobj = 0;
7139 wxMouseState *arg1 = (wxMouseState *) 0 ;
7140 int result;
7141 void *argp1 = 0 ;
7142 int res1 = 0 ;
7143 PyObject *swig_obj[1] ;
7144
7145 if (!args) SWIG_fail;
7146 swig_obj[0] = args;
7147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7148 if (!SWIG_IsOK(res1)) {
7149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7150 }
7151 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7152 {
7153 PyThreadState* __tstate = wxPyBeginAllowThreads();
7154 result = (int)(arg1)->GetX();
7155 wxPyEndAllowThreads(__tstate);
7156 if (PyErr_Occurred()) SWIG_fail;
7157 }
7158 resultobj = SWIG_From_int(static_cast< int >(result));
7159 return resultobj;
7160 fail:
7161 return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7166 PyObject *resultobj = 0;
7167 wxMouseState *arg1 = (wxMouseState *) 0 ;
7168 int result;
7169 void *argp1 = 0 ;
7170 int res1 = 0 ;
7171 PyObject *swig_obj[1] ;
7172
7173 if (!args) SWIG_fail;
7174 swig_obj[0] = args;
7175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7176 if (!SWIG_IsOK(res1)) {
7177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7178 }
7179 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7180 {
7181 PyThreadState* __tstate = wxPyBeginAllowThreads();
7182 result = (int)(arg1)->GetY();
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 resultobj = SWIG_From_int(static_cast< int >(result));
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7194 PyObject *resultobj = 0;
7195 wxMouseState *arg1 = (wxMouseState *) 0 ;
7196 bool result;
7197 void *argp1 = 0 ;
7198 int res1 = 0 ;
7199 PyObject *swig_obj[1] ;
7200
7201 if (!args) SWIG_fail;
7202 swig_obj[0] = args;
7203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7204 if (!SWIG_IsOK(res1)) {
7205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7206 }
7207 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7208 {
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 result = (bool)(arg1)->LeftDown();
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 {
7215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7216 }
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7224 PyObject *resultobj = 0;
7225 wxMouseState *arg1 = (wxMouseState *) 0 ;
7226 bool result;
7227 void *argp1 = 0 ;
7228 int res1 = 0 ;
7229 PyObject *swig_obj[1] ;
7230
7231 if (!args) SWIG_fail;
7232 swig_obj[0] = args;
7233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7234 if (!SWIG_IsOK(res1)) {
7235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7236 }
7237 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7238 {
7239 PyThreadState* __tstate = wxPyBeginAllowThreads();
7240 result = (bool)(arg1)->MiddleDown();
7241 wxPyEndAllowThreads(__tstate);
7242 if (PyErr_Occurred()) SWIG_fail;
7243 }
7244 {
7245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7246 }
7247 return resultobj;
7248 fail:
7249 return NULL;
7250 }
7251
7252
7253 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7254 PyObject *resultobj = 0;
7255 wxMouseState *arg1 = (wxMouseState *) 0 ;
7256 bool result;
7257 void *argp1 = 0 ;
7258 int res1 = 0 ;
7259 PyObject *swig_obj[1] ;
7260
7261 if (!args) SWIG_fail;
7262 swig_obj[0] = args;
7263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7264 if (!SWIG_IsOK(res1)) {
7265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7266 }
7267 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7268 {
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 result = (bool)(arg1)->RightDown();
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 return resultobj;
7278 fail:
7279 return NULL;
7280 }
7281
7282
7283 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7284 PyObject *resultobj = 0;
7285 wxMouseState *arg1 = (wxMouseState *) 0 ;
7286 bool result;
7287 void *argp1 = 0 ;
7288 int res1 = 0 ;
7289 PyObject *swig_obj[1] ;
7290
7291 if (!args) SWIG_fail;
7292 swig_obj[0] = args;
7293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7296 }
7297 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7298 {
7299 PyThreadState* __tstate = wxPyBeginAllowThreads();
7300 result = (bool)(arg1)->ControlDown();
7301 wxPyEndAllowThreads(__tstate);
7302 if (PyErr_Occurred()) SWIG_fail;
7303 }
7304 {
7305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7306 }
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7314 PyObject *resultobj = 0;
7315 wxMouseState *arg1 = (wxMouseState *) 0 ;
7316 bool result;
7317 void *argp1 = 0 ;
7318 int res1 = 0 ;
7319 PyObject *swig_obj[1] ;
7320
7321 if (!args) SWIG_fail;
7322 swig_obj[0] = args;
7323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7324 if (!SWIG_IsOK(res1)) {
7325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7326 }
7327 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7328 {
7329 PyThreadState* __tstate = wxPyBeginAllowThreads();
7330 result = (bool)(arg1)->ShiftDown();
7331 wxPyEndAllowThreads(__tstate);
7332 if (PyErr_Occurred()) SWIG_fail;
7333 }
7334 {
7335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7336 }
7337 return resultobj;
7338 fail:
7339 return NULL;
7340 }
7341
7342
7343 SWIGINTERN PyObject *_wrap_MouseState_AltDown(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_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7356 }
7357 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7358 {
7359 PyThreadState* __tstate = wxPyBeginAllowThreads();
7360 result = (bool)(arg1)->AltDown();
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_MetaDown(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_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7386 }
7387 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7388 {
7389 PyThreadState* __tstate = wxPyBeginAllowThreads();
7390 result = (bool)(arg1)->MetaDown();
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_CmdDown(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_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7416 }
7417 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7418 {
7419 PyThreadState* __tstate = wxPyBeginAllowThreads();
7420 result = (bool)(arg1)->CmdDown();
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_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj = 0;
7435 wxMouseState *arg1 = (wxMouseState *) 0 ;
7436 int arg2 ;
7437 void *argp1 = 0 ;
7438 int res1 = 0 ;
7439 int val2 ;
7440 int ecode2 = 0 ;
7441 PyObject * obj0 = 0 ;
7442 PyObject * obj1 = 0 ;
7443 char * kwnames[] = {
7444 (char *) "self",(char *) "x", NULL
7445 };
7446
7447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7449 if (!SWIG_IsOK(res1)) {
7450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7451 }
7452 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7453 ecode2 = SWIG_AsVal_int(obj1, &val2);
7454 if (!SWIG_IsOK(ecode2)) {
7455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7456 }
7457 arg2 = static_cast< int >(val2);
7458 {
7459 PyThreadState* __tstate = wxPyBeginAllowThreads();
7460 (arg1)->SetX(arg2);
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 resultobj = SWIG_Py_Void();
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj = 0;
7473 wxMouseState *arg1 = (wxMouseState *) 0 ;
7474 int arg2 ;
7475 void *argp1 = 0 ;
7476 int res1 = 0 ;
7477 int val2 ;
7478 int ecode2 = 0 ;
7479 PyObject * obj0 = 0 ;
7480 PyObject * obj1 = 0 ;
7481 char * kwnames[] = {
7482 (char *) "self",(char *) "y", NULL
7483 };
7484
7485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7487 if (!SWIG_IsOK(res1)) {
7488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7489 }
7490 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7491 ecode2 = SWIG_AsVal_int(obj1, &val2);
7492 if (!SWIG_IsOK(ecode2)) {
7493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7494 }
7495 arg2 = static_cast< int >(val2);
7496 {
7497 PyThreadState* __tstate = wxPyBeginAllowThreads();
7498 (arg1)->SetY(arg2);
7499 wxPyEndAllowThreads(__tstate);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 resultobj = SWIG_Py_Void();
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj = 0;
7511 wxMouseState *arg1 = (wxMouseState *) 0 ;
7512 bool arg2 ;
7513 void *argp1 = 0 ;
7514 int res1 = 0 ;
7515 bool val2 ;
7516 int ecode2 = 0 ;
7517 PyObject * obj0 = 0 ;
7518 PyObject * obj1 = 0 ;
7519 char * kwnames[] = {
7520 (char *) "self",(char *) "down", NULL
7521 };
7522
7523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7525 if (!SWIG_IsOK(res1)) {
7526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7527 }
7528 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7529 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7530 if (!SWIG_IsOK(ecode2)) {
7531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7532 }
7533 arg2 = static_cast< bool >(val2);
7534 {
7535 PyThreadState* __tstate = wxPyBeginAllowThreads();
7536 (arg1)->SetLeftDown(arg2);
7537 wxPyEndAllowThreads(__tstate);
7538 if (PyErr_Occurred()) SWIG_fail;
7539 }
7540 resultobj = SWIG_Py_Void();
7541 return resultobj;
7542 fail:
7543 return NULL;
7544 }
7545
7546
7547 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7548 PyObject *resultobj = 0;
7549 wxMouseState *arg1 = (wxMouseState *) 0 ;
7550 bool arg2 ;
7551 void *argp1 = 0 ;
7552 int res1 = 0 ;
7553 bool val2 ;
7554 int ecode2 = 0 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 char * kwnames[] = {
7558 (char *) "self",(char *) "down", NULL
7559 };
7560
7561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7563 if (!SWIG_IsOK(res1)) {
7564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7565 }
7566 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7568 if (!SWIG_IsOK(ecode2)) {
7569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7570 }
7571 arg2 = static_cast< bool >(val2);
7572 {
7573 PyThreadState* __tstate = wxPyBeginAllowThreads();
7574 (arg1)->SetMiddleDown(arg2);
7575 wxPyEndAllowThreads(__tstate);
7576 if (PyErr_Occurred()) SWIG_fail;
7577 }
7578 resultobj = SWIG_Py_Void();
7579 return resultobj;
7580 fail:
7581 return NULL;
7582 }
7583
7584
7585 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7586 PyObject *resultobj = 0;
7587 wxMouseState *arg1 = (wxMouseState *) 0 ;
7588 bool arg2 ;
7589 void *argp1 = 0 ;
7590 int res1 = 0 ;
7591 bool val2 ;
7592 int ecode2 = 0 ;
7593 PyObject * obj0 = 0 ;
7594 PyObject * obj1 = 0 ;
7595 char * kwnames[] = {
7596 (char *) "self",(char *) "down", NULL
7597 };
7598
7599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7601 if (!SWIG_IsOK(res1)) {
7602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7603 }
7604 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7605 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7606 if (!SWIG_IsOK(ecode2)) {
7607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7608 }
7609 arg2 = static_cast< bool >(val2);
7610 {
7611 PyThreadState* __tstate = wxPyBeginAllowThreads();
7612 (arg1)->SetRightDown(arg2);
7613 wxPyEndAllowThreads(__tstate);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 resultobj = SWIG_Py_Void();
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7624 PyObject *resultobj = 0;
7625 wxMouseState *arg1 = (wxMouseState *) 0 ;
7626 bool arg2 ;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 bool val2 ;
7630 int ecode2 = 0 ;
7631 PyObject * obj0 = 0 ;
7632 PyObject * obj1 = 0 ;
7633 char * kwnames[] = {
7634 (char *) "self",(char *) "down", NULL
7635 };
7636
7637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7641 }
7642 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7643 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7644 if (!SWIG_IsOK(ecode2)) {
7645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7646 }
7647 arg2 = static_cast< bool >(val2);
7648 {
7649 PyThreadState* __tstate = wxPyBeginAllowThreads();
7650 (arg1)->SetControlDown(arg2);
7651 wxPyEndAllowThreads(__tstate);
7652 if (PyErr_Occurred()) SWIG_fail;
7653 }
7654 resultobj = SWIG_Py_Void();
7655 return resultobj;
7656 fail:
7657 return NULL;
7658 }
7659
7660
7661 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7662 PyObject *resultobj = 0;
7663 wxMouseState *arg1 = (wxMouseState *) 0 ;
7664 bool arg2 ;
7665 void *argp1 = 0 ;
7666 int res1 = 0 ;
7667 bool val2 ;
7668 int ecode2 = 0 ;
7669 PyObject * obj0 = 0 ;
7670 PyObject * obj1 = 0 ;
7671 char * kwnames[] = {
7672 (char *) "self",(char *) "down", NULL
7673 };
7674
7675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7677 if (!SWIG_IsOK(res1)) {
7678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7679 }
7680 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7682 if (!SWIG_IsOK(ecode2)) {
7683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7684 }
7685 arg2 = static_cast< bool >(val2);
7686 {
7687 PyThreadState* __tstate = wxPyBeginAllowThreads();
7688 (arg1)->SetShiftDown(arg2);
7689 wxPyEndAllowThreads(__tstate);
7690 if (PyErr_Occurred()) SWIG_fail;
7691 }
7692 resultobj = SWIG_Py_Void();
7693 return resultobj;
7694 fail:
7695 return NULL;
7696 }
7697
7698
7699 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7700 PyObject *resultobj = 0;
7701 wxMouseState *arg1 = (wxMouseState *) 0 ;
7702 bool arg2 ;
7703 void *argp1 = 0 ;
7704 int res1 = 0 ;
7705 bool val2 ;
7706 int ecode2 = 0 ;
7707 PyObject * obj0 = 0 ;
7708 PyObject * obj1 = 0 ;
7709 char * kwnames[] = {
7710 (char *) "self",(char *) "down", NULL
7711 };
7712
7713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7715 if (!SWIG_IsOK(res1)) {
7716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7717 }
7718 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7719 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7720 if (!SWIG_IsOK(ecode2)) {
7721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7722 }
7723 arg2 = static_cast< bool >(val2);
7724 {
7725 PyThreadState* __tstate = wxPyBeginAllowThreads();
7726 (arg1)->SetAltDown(arg2);
7727 wxPyEndAllowThreads(__tstate);
7728 if (PyErr_Occurred()) SWIG_fail;
7729 }
7730 resultobj = SWIG_Py_Void();
7731 return resultobj;
7732 fail:
7733 return NULL;
7734 }
7735
7736
7737 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7738 PyObject *resultobj = 0;
7739 wxMouseState *arg1 = (wxMouseState *) 0 ;
7740 bool arg2 ;
7741 void *argp1 = 0 ;
7742 int res1 = 0 ;
7743 bool val2 ;
7744 int ecode2 = 0 ;
7745 PyObject * obj0 = 0 ;
7746 PyObject * obj1 = 0 ;
7747 char * kwnames[] = {
7748 (char *) "self",(char *) "down", NULL
7749 };
7750
7751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7753 if (!SWIG_IsOK(res1)) {
7754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7755 }
7756 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7758 if (!SWIG_IsOK(ecode2)) {
7759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7760 }
7761 arg2 = static_cast< bool >(val2);
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 (arg1)->SetMetaDown(arg2);
7765 wxPyEndAllowThreads(__tstate);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 resultobj = SWIG_Py_Void();
7769 return resultobj;
7770 fail:
7771 return NULL;
7772 }
7773
7774
7775 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7776 PyObject *obj;
7777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7778 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7779 return SWIG_Py_Void();
7780 }
7781
7782 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7783 return SWIG_Python_InitShadowInstance(args);
7784 }
7785
7786 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7787 PyObject *resultobj = 0;
7788 wxMouseState result;
7789
7790 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7791 {
7792 PyThreadState* __tstate = wxPyBeginAllowThreads();
7793 result = wxGetMouseState();
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7798 return resultobj;
7799 fail:
7800 return NULL;
7801 }
7802
7803
7804 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7805 PyObject *resultobj = 0;
7806
7807 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7808 {
7809 if (!wxPyCheckForApp()) SWIG_fail;
7810 PyThreadState* __tstate = wxPyBeginAllowThreads();
7811 wxWakeUpMainThread();
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 resultobj = SWIG_Py_Void();
7816 return resultobj;
7817 fail:
7818 return NULL;
7819 }
7820
7821
7822 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7823 PyObject *resultobj = 0;
7824
7825 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7826 {
7827 if (!wxPyCheckForApp()) SWIG_fail;
7828 PyThreadState* __tstate = wxPyBeginAllowThreads();
7829 wxMutexGuiEnter();
7830 wxPyEndAllowThreads(__tstate);
7831 if (PyErr_Occurred()) SWIG_fail;
7832 }
7833 resultobj = SWIG_Py_Void();
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7841 PyObject *resultobj = 0;
7842
7843 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7844 {
7845 if (!wxPyCheckForApp()) SWIG_fail;
7846 PyThreadState* __tstate = wxPyBeginAllowThreads();
7847 wxMutexGuiLeave();
7848 wxPyEndAllowThreads(__tstate);
7849 if (PyErr_Occurred()) SWIG_fail;
7850 }
7851 resultobj = SWIG_Py_Void();
7852 return resultobj;
7853 fail:
7854 return NULL;
7855 }
7856
7857
7858 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7859 PyObject *resultobj = 0;
7860 wxMutexGuiLocker *result = 0 ;
7861
7862 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7863 {
7864 if (!wxPyCheckForApp()) SWIG_fail;
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 PyObject *resultobj = 0;
7879 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7880 void *argp1 = 0 ;
7881 int res1 = 0 ;
7882 PyObject *swig_obj[1] ;
7883
7884 if (!args) SWIG_fail;
7885 swig_obj[0] = args;
7886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7887 if (!SWIG_IsOK(res1)) {
7888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7889 }
7890 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 delete arg1;
7894
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 resultobj = SWIG_Py_Void();
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7906 PyObject *obj;
7907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7908 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7909 return SWIG_Py_Void();
7910 }
7911
7912 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7913 return SWIG_Python_InitShadowInstance(args);
7914 }
7915
7916 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7917 PyObject *resultobj = 0;
7918 bool result;
7919
7920 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7921 {
7922 PyThreadState* __tstate = wxPyBeginAllowThreads();
7923 result = (bool)wxThread_IsMain();
7924 wxPyEndAllowThreads(__tstate);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 {
7928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7929 }
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj = 0;
7938 wxString *arg1 = 0 ;
7939 wxToolTip *result = 0 ;
7940 bool temp1 = false ;
7941 PyObject * obj0 = 0 ;
7942 char * kwnames[] = {
7943 (char *) "tip", NULL
7944 };
7945
7946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7947 {
7948 arg1 = wxString_in_helper(obj0);
7949 if (arg1 == NULL) SWIG_fail;
7950 temp1 = true;
7951 }
7952 {
7953 if (!wxPyCheckForApp()) SWIG_fail;
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7960 {
7961 if (temp1)
7962 delete arg1;
7963 }
7964 return resultobj;
7965 fail:
7966 {
7967 if (temp1)
7968 delete arg1;
7969 }
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7975 PyObject *resultobj = 0;
7976 wxToolTip *arg1 = (wxToolTip *) 0 ;
7977 void *argp1 = 0 ;
7978 int res1 = 0 ;
7979 PyObject *swig_obj[1] ;
7980
7981 if (!args) SWIG_fail;
7982 swig_obj[0] = args;
7983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
7984 if (!SWIG_IsOK(res1)) {
7985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
7986 }
7987 arg1 = reinterpret_cast< wxToolTip * >(argp1);
7988 {
7989 PyThreadState* __tstate = wxPyBeginAllowThreads();
7990 delete arg1;
7991
7992 wxPyEndAllowThreads(__tstate);
7993 if (PyErr_Occurred()) SWIG_fail;
7994 }
7995 resultobj = SWIG_Py_Void();
7996 return resultobj;
7997 fail:
7998 return NULL;
7999 }
8000
8001
8002 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8003 PyObject *resultobj = 0;
8004 wxToolTip *arg1 = (wxToolTip *) 0 ;
8005 wxString *arg2 = 0 ;
8006 void *argp1 = 0 ;
8007 int res1 = 0 ;
8008 bool temp2 = false ;
8009 PyObject * obj0 = 0 ;
8010 PyObject * obj1 = 0 ;
8011 char * kwnames[] = {
8012 (char *) "self",(char *) "tip", NULL
8013 };
8014
8015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8017 if (!SWIG_IsOK(res1)) {
8018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8019 }
8020 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8021 {
8022 arg2 = wxString_in_helper(obj1);
8023 if (arg2 == NULL) SWIG_fail;
8024 temp2 = true;
8025 }
8026 {
8027 PyThreadState* __tstate = wxPyBeginAllowThreads();
8028 (arg1)->SetTip((wxString const &)*arg2);
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 resultobj = SWIG_Py_Void();
8033 {
8034 if (temp2)
8035 delete arg2;
8036 }
8037 return resultobj;
8038 fail:
8039 {
8040 if (temp2)
8041 delete arg2;
8042 }
8043 return NULL;
8044 }
8045
8046
8047 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8048 PyObject *resultobj = 0;
8049 wxToolTip *arg1 = (wxToolTip *) 0 ;
8050 wxString result;
8051 void *argp1 = 0 ;
8052 int res1 = 0 ;
8053 PyObject *swig_obj[1] ;
8054
8055 if (!args) SWIG_fail;
8056 swig_obj[0] = args;
8057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8058 if (!SWIG_IsOK(res1)) {
8059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8060 }
8061 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 result = (arg1)->GetTip();
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 {
8069 #if wxUSE_UNICODE
8070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8071 #else
8072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8073 #endif
8074 }
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8082 PyObject *resultobj = 0;
8083 wxToolTip *arg1 = (wxToolTip *) 0 ;
8084 wxWindow *result = 0 ;
8085 void *argp1 = 0 ;
8086 int res1 = 0 ;
8087 PyObject *swig_obj[1] ;
8088
8089 if (!args) SWIG_fail;
8090 swig_obj[0] = args;
8091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8092 if (!SWIG_IsOK(res1)) {
8093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8094 }
8095 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8096 {
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 result = (wxWindow *)(arg1)->GetWindow();
8099 wxPyEndAllowThreads(__tstate);
8100 if (PyErr_Occurred()) SWIG_fail;
8101 }
8102 {
8103 resultobj = wxPyMake_wxObject(result, 0);
8104 }
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8112 PyObject *resultobj = 0;
8113 bool arg1 ;
8114 bool val1 ;
8115 int ecode1 = 0 ;
8116 PyObject * obj0 = 0 ;
8117 char * kwnames[] = {
8118 (char *) "flag", NULL
8119 };
8120
8121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8122 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8123 if (!SWIG_IsOK(ecode1)) {
8124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8125 }
8126 arg1 = static_cast< bool >(val1);
8127 {
8128 PyThreadState* __tstate = wxPyBeginAllowThreads();
8129 wxToolTip::Enable(arg1);
8130 wxPyEndAllowThreads(__tstate);
8131 if (PyErr_Occurred()) SWIG_fail;
8132 }
8133 resultobj = SWIG_Py_Void();
8134 return resultobj;
8135 fail:
8136 return NULL;
8137 }
8138
8139
8140 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8141 PyObject *resultobj = 0;
8142 long arg1 ;
8143 long val1 ;
8144 int ecode1 = 0 ;
8145 PyObject * obj0 = 0 ;
8146 char * kwnames[] = {
8147 (char *) "milliseconds", NULL
8148 };
8149
8150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8151 ecode1 = SWIG_AsVal_long(obj0, &val1);
8152 if (!SWIG_IsOK(ecode1)) {
8153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8154 }
8155 arg1 = static_cast< long >(val1);
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 wxToolTip::SetDelay(arg1);
8159 wxPyEndAllowThreads(__tstate);
8160 if (PyErr_Occurred()) SWIG_fail;
8161 }
8162 resultobj = SWIG_Py_Void();
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8170 PyObject *obj;
8171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8172 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8173 return SWIG_Py_Void();
8174 }
8175
8176 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8177 return SWIG_Python_InitShadowInstance(args);
8178 }
8179
8180 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8181 PyObject *resultobj = 0;
8182 wxWindow *arg1 = (wxWindow *) 0 ;
8183 wxSize *arg2 = 0 ;
8184 wxCaret *result = 0 ;
8185 void *argp1 = 0 ;
8186 int res1 = 0 ;
8187 wxSize temp2 ;
8188 PyObject * obj0 = 0 ;
8189 PyObject * obj1 = 0 ;
8190 char * kwnames[] = {
8191 (char *) "window",(char *) "size", NULL
8192 };
8193
8194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8196 if (!SWIG_IsOK(res1)) {
8197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8198 }
8199 arg1 = reinterpret_cast< wxWindow * >(argp1);
8200 {
8201 arg2 = &temp2;
8202 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8203 }
8204 {
8205 if (!wxPyCheckForApp()) SWIG_fail;
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8219 PyObject *resultobj = 0;
8220 wxCaret *arg1 = (wxCaret *) 0 ;
8221 void *argp1 = 0 ;
8222 int res1 = 0 ;
8223 PyObject *swig_obj[1] ;
8224
8225 if (!args) SWIG_fail;
8226 swig_obj[0] = args;
8227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8228 if (!SWIG_IsOK(res1)) {
8229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8230 }
8231 arg1 = reinterpret_cast< wxCaret * >(argp1);
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 delete arg1;
8235
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 resultobj = SWIG_Py_Void();
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8247 PyObject *resultobj = 0;
8248 wxCaret *arg1 = (wxCaret *) 0 ;
8249 void *argp1 = 0 ;
8250 int res1 = 0 ;
8251 PyObject *swig_obj[1] ;
8252
8253 if (!args) SWIG_fail;
8254 swig_obj[0] = args;
8255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8256 if (!SWIG_IsOK(res1)) {
8257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8258 }
8259 arg1 = reinterpret_cast< wxCaret * >(argp1);
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 wxCaret_Destroy(arg1);
8263 wxPyEndAllowThreads(__tstate);
8264 if (PyErr_Occurred()) SWIG_fail;
8265 }
8266 resultobj = SWIG_Py_Void();
8267 return resultobj;
8268 fail:
8269 return NULL;
8270 }
8271
8272
8273 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274 PyObject *resultobj = 0;
8275 wxCaret *arg1 = (wxCaret *) 0 ;
8276 bool result;
8277 void *argp1 = 0 ;
8278 int res1 = 0 ;
8279 PyObject *swig_obj[1] ;
8280
8281 if (!args) SWIG_fail;
8282 swig_obj[0] = args;
8283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8284 if (!SWIG_IsOK(res1)) {
8285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8286 }
8287 arg1 = reinterpret_cast< wxCaret * >(argp1);
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 result = (bool)(arg1)->IsOk();
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 {
8295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8296 }
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8304 PyObject *resultobj = 0;
8305 wxCaret *arg1 = (wxCaret *) 0 ;
8306 bool result;
8307 void *argp1 = 0 ;
8308 int res1 = 0 ;
8309 PyObject *swig_obj[1] ;
8310
8311 if (!args) SWIG_fail;
8312 swig_obj[0] = args;
8313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8314 if (!SWIG_IsOK(res1)) {
8315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8316 }
8317 arg1 = reinterpret_cast< wxCaret * >(argp1);
8318 {
8319 PyThreadState* __tstate = wxPyBeginAllowThreads();
8320 result = (bool)(arg1)->IsVisible();
8321 wxPyEndAllowThreads(__tstate);
8322 if (PyErr_Occurred()) SWIG_fail;
8323 }
8324 {
8325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8326 }
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
8333 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8334 PyObject *resultobj = 0;
8335 wxCaret *arg1 = (wxCaret *) 0 ;
8336 wxPoint result;
8337 void *argp1 = 0 ;
8338 int res1 = 0 ;
8339 PyObject *swig_obj[1] ;
8340
8341 if (!args) SWIG_fail;
8342 swig_obj[0] = args;
8343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8344 if (!SWIG_IsOK(res1)) {
8345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8346 }
8347 arg1 = reinterpret_cast< wxCaret * >(argp1);
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (arg1)->GetPosition();
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8362 PyObject *resultobj = 0;
8363 wxCaret *arg1 = (wxCaret *) 0 ;
8364 int *arg2 = (int *) 0 ;
8365 int *arg3 = (int *) 0 ;
8366 void *argp1 = 0 ;
8367 int res1 = 0 ;
8368 int temp2 ;
8369 int res2 = SWIG_TMPOBJ ;
8370 int temp3 ;
8371 int res3 = SWIG_TMPOBJ ;
8372 PyObject *swig_obj[1] ;
8373
8374 arg2 = &temp2;
8375 arg3 = &temp3;
8376 if (!args) SWIG_fail;
8377 swig_obj[0] = args;
8378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8379 if (!SWIG_IsOK(res1)) {
8380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8381 }
8382 arg1 = reinterpret_cast< wxCaret * >(argp1);
8383 {
8384 PyThreadState* __tstate = wxPyBeginAllowThreads();
8385 (arg1)->GetPosition(arg2,arg3);
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 resultobj = SWIG_Py_Void();
8390 if (SWIG_IsTmpObj(res2)) {
8391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8392 } else {
8393 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8395 }
8396 if (SWIG_IsTmpObj(res3)) {
8397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8398 } else {
8399 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8401 }
8402 return resultobj;
8403 fail:
8404 return NULL;
8405 }
8406
8407
8408 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8409 PyObject *resultobj = 0;
8410 wxCaret *arg1 = (wxCaret *) 0 ;
8411 wxSize result;
8412 void *argp1 = 0 ;
8413 int res1 = 0 ;
8414 PyObject *swig_obj[1] ;
8415
8416 if (!args) SWIG_fail;
8417 swig_obj[0] = args;
8418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8419 if (!SWIG_IsOK(res1)) {
8420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8421 }
8422 arg1 = reinterpret_cast< wxCaret * >(argp1);
8423 {
8424 PyThreadState* __tstate = wxPyBeginAllowThreads();
8425 result = (arg1)->GetSize();
8426 wxPyEndAllowThreads(__tstate);
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8437 PyObject *resultobj = 0;
8438 wxCaret *arg1 = (wxCaret *) 0 ;
8439 int *arg2 = (int *) 0 ;
8440 int *arg3 = (int *) 0 ;
8441 void *argp1 = 0 ;
8442 int res1 = 0 ;
8443 int temp2 ;
8444 int res2 = SWIG_TMPOBJ ;
8445 int temp3 ;
8446 int res3 = SWIG_TMPOBJ ;
8447 PyObject *swig_obj[1] ;
8448
8449 arg2 = &temp2;
8450 arg3 = &temp3;
8451 if (!args) SWIG_fail;
8452 swig_obj[0] = args;
8453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8454 if (!SWIG_IsOK(res1)) {
8455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8456 }
8457 arg1 = reinterpret_cast< wxCaret * >(argp1);
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 (arg1)->GetSize(arg2,arg3);
8461 wxPyEndAllowThreads(__tstate);
8462 if (PyErr_Occurred()) SWIG_fail;
8463 }
8464 resultobj = SWIG_Py_Void();
8465 if (SWIG_IsTmpObj(res2)) {
8466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8467 } else {
8468 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8470 }
8471 if (SWIG_IsTmpObj(res3)) {
8472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8473 } else {
8474 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8476 }
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8484 PyObject *resultobj = 0;
8485 wxCaret *arg1 = (wxCaret *) 0 ;
8486 wxWindow *result = 0 ;
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_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8496 }
8497 arg1 = reinterpret_cast< wxCaret * >(argp1);
8498 {
8499 PyThreadState* __tstate = wxPyBeginAllowThreads();
8500 result = (wxWindow *)(arg1)->GetWindow();
8501 wxPyEndAllowThreads(__tstate);
8502 if (PyErr_Occurred()) SWIG_fail;
8503 }
8504 {
8505 resultobj = wxPyMake_wxObject(result, 0);
8506 }
8507 return resultobj;
8508 fail:
8509 return NULL;
8510 }
8511
8512
8513 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8514 PyObject *resultobj = 0;
8515 wxCaret *arg1 = (wxCaret *) 0 ;
8516 int arg2 ;
8517 int arg3 ;
8518 void *argp1 = 0 ;
8519 int res1 = 0 ;
8520 int val2 ;
8521 int ecode2 = 0 ;
8522 int val3 ;
8523 int ecode3 = 0 ;
8524 PyObject * obj0 = 0 ;
8525 PyObject * obj1 = 0 ;
8526 PyObject * obj2 = 0 ;
8527 char * kwnames[] = {
8528 (char *) "self",(char *) "x",(char *) "y", NULL
8529 };
8530
8531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8533 if (!SWIG_IsOK(res1)) {
8534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8535 }
8536 arg1 = reinterpret_cast< wxCaret * >(argp1);
8537 ecode2 = SWIG_AsVal_int(obj1, &val2);
8538 if (!SWIG_IsOK(ecode2)) {
8539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8540 }
8541 arg2 = static_cast< int >(val2);
8542 ecode3 = SWIG_AsVal_int(obj2, &val3);
8543 if (!SWIG_IsOK(ecode3)) {
8544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8545 }
8546 arg3 = static_cast< int >(val3);
8547 {
8548 PyThreadState* __tstate = wxPyBeginAllowThreads();
8549 (arg1)->Move(arg2,arg3);
8550 wxPyEndAllowThreads(__tstate);
8551 if (PyErr_Occurred()) SWIG_fail;
8552 }
8553 resultobj = SWIG_Py_Void();
8554 return resultobj;
8555 fail:
8556 return NULL;
8557 }
8558
8559
8560 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8561 PyObject *resultobj = 0;
8562 wxCaret *arg1 = (wxCaret *) 0 ;
8563 wxPoint *arg2 = 0 ;
8564 void *argp1 = 0 ;
8565 int res1 = 0 ;
8566 wxPoint temp2 ;
8567 PyObject * obj0 = 0 ;
8568 PyObject * obj1 = 0 ;
8569 char * kwnames[] = {
8570 (char *) "self",(char *) "pt", NULL
8571 };
8572
8573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8575 if (!SWIG_IsOK(res1)) {
8576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8577 }
8578 arg1 = reinterpret_cast< wxCaret * >(argp1);
8579 {
8580 arg2 = &temp2;
8581 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8582 }
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 (arg1)->Move((wxPoint const &)*arg2);
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_Py_Void();
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj = 0;
8598 wxCaret *arg1 = (wxCaret *) 0 ;
8599 int arg2 ;
8600 int arg3 ;
8601 void *argp1 = 0 ;
8602 int res1 = 0 ;
8603 int val2 ;
8604 int ecode2 = 0 ;
8605 int val3 ;
8606 int ecode3 = 0 ;
8607 PyObject * obj0 = 0 ;
8608 PyObject * obj1 = 0 ;
8609 PyObject * obj2 = 0 ;
8610 char * kwnames[] = {
8611 (char *) "self",(char *) "width",(char *) "height", NULL
8612 };
8613
8614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8616 if (!SWIG_IsOK(res1)) {
8617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8618 }
8619 arg1 = reinterpret_cast< wxCaret * >(argp1);
8620 ecode2 = SWIG_AsVal_int(obj1, &val2);
8621 if (!SWIG_IsOK(ecode2)) {
8622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8623 }
8624 arg2 = static_cast< int >(val2);
8625 ecode3 = SWIG_AsVal_int(obj2, &val3);
8626 if (!SWIG_IsOK(ecode3)) {
8627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8628 }
8629 arg3 = static_cast< int >(val3);
8630 {
8631 PyThreadState* __tstate = wxPyBeginAllowThreads();
8632 (arg1)->SetSize(arg2,arg3);
8633 wxPyEndAllowThreads(__tstate);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 resultobj = SWIG_Py_Void();
8637 return resultobj;
8638 fail:
8639 return NULL;
8640 }
8641
8642
8643 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8644 PyObject *resultobj = 0;
8645 wxCaret *arg1 = (wxCaret *) 0 ;
8646 wxSize *arg2 = 0 ;
8647 void *argp1 = 0 ;
8648 int res1 = 0 ;
8649 wxSize temp2 ;
8650 PyObject * obj0 = 0 ;
8651 PyObject * obj1 = 0 ;
8652 char * kwnames[] = {
8653 (char *) "self",(char *) "size", NULL
8654 };
8655
8656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8658 if (!SWIG_IsOK(res1)) {
8659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8660 }
8661 arg1 = reinterpret_cast< wxCaret * >(argp1);
8662 {
8663 arg2 = &temp2;
8664 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8665 }
8666 {
8667 PyThreadState* __tstate = wxPyBeginAllowThreads();
8668 (arg1)->SetSize((wxSize const &)*arg2);
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 resultobj = SWIG_Py_Void();
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8680 PyObject *resultobj = 0;
8681 wxCaret *arg1 = (wxCaret *) 0 ;
8682 int arg2 = (int) true ;
8683 void *argp1 = 0 ;
8684 int res1 = 0 ;
8685 int val2 ;
8686 int ecode2 = 0 ;
8687 PyObject * obj0 = 0 ;
8688 PyObject * obj1 = 0 ;
8689 char * kwnames[] = {
8690 (char *) "self",(char *) "show", NULL
8691 };
8692
8693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8697 }
8698 arg1 = reinterpret_cast< wxCaret * >(argp1);
8699 if (obj1) {
8700 ecode2 = SWIG_AsVal_int(obj1, &val2);
8701 if (!SWIG_IsOK(ecode2)) {
8702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8703 }
8704 arg2 = static_cast< int >(val2);
8705 }
8706 {
8707 PyThreadState* __tstate = wxPyBeginAllowThreads();
8708 (arg1)->Show(arg2);
8709 wxPyEndAllowThreads(__tstate);
8710 if (PyErr_Occurred()) SWIG_fail;
8711 }
8712 resultobj = SWIG_Py_Void();
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8720 PyObject *resultobj = 0;
8721 wxCaret *arg1 = (wxCaret *) 0 ;
8722 void *argp1 = 0 ;
8723 int res1 = 0 ;
8724 PyObject *swig_obj[1] ;
8725
8726 if (!args) SWIG_fail;
8727 swig_obj[0] = args;
8728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8729 if (!SWIG_IsOK(res1)) {
8730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8731 }
8732 arg1 = reinterpret_cast< wxCaret * >(argp1);
8733 {
8734 PyThreadState* __tstate = wxPyBeginAllowThreads();
8735 (arg1)->Hide();
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_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8747 PyObject *resultobj = 0;
8748 int result;
8749
8750 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8751 {
8752 PyThreadState* __tstate = wxPyBeginAllowThreads();
8753 result = (int)wxCaret::GetBlinkTime();
8754 wxPyEndAllowThreads(__tstate);
8755 if (PyErr_Occurred()) SWIG_fail;
8756 }
8757 resultobj = SWIG_From_int(static_cast< int >(result));
8758 return resultobj;
8759 fail:
8760 return NULL;
8761 }
8762
8763
8764 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8765 PyObject *resultobj = 0;
8766 int arg1 ;
8767 int val1 ;
8768 int ecode1 = 0 ;
8769 PyObject * obj0 = 0 ;
8770 char * kwnames[] = {
8771 (char *) "milliseconds", NULL
8772 };
8773
8774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8775 ecode1 = SWIG_AsVal_int(obj0, &val1);
8776 if (!SWIG_IsOK(ecode1)) {
8777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8778 }
8779 arg1 = static_cast< int >(val1);
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 wxCaret::SetBlinkTime(arg1);
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 *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8794 PyObject *obj;
8795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8796 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8797 return SWIG_Py_Void();
8798 }
8799
8800 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8801 return SWIG_Python_InitShadowInstance(args);
8802 }
8803
8804 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj = 0;
8806 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8807 wxBusyCursor *result = 0 ;
8808 void *argp1 = 0 ;
8809 int res1 = 0 ;
8810 PyObject * obj0 = 0 ;
8811 char * kwnames[] = {
8812 (char *) "cursor", NULL
8813 };
8814
8815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8816 if (obj0) {
8817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8818 if (!SWIG_IsOK(res1)) {
8819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8820 }
8821 arg1 = reinterpret_cast< wxCursor * >(argp1);
8822 }
8823 {
8824 if (!wxPyCheckForApp()) SWIG_fail;
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838 PyObject *resultobj = 0;
8839 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8840 void *argp1 = 0 ;
8841 int res1 = 0 ;
8842 PyObject *swig_obj[1] ;
8843
8844 if (!args) SWIG_fail;
8845 swig_obj[0] = args;
8846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8847 if (!SWIG_IsOK(res1)) {
8848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8849 }
8850 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8851 {
8852 PyThreadState* __tstate = wxPyBeginAllowThreads();
8853 delete arg1;
8854
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 resultobj = SWIG_Py_Void();
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8866 PyObject *obj;
8867 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8868 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8869 return SWIG_Py_Void();
8870 }
8871
8872 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8873 return SWIG_Python_InitShadowInstance(args);
8874 }
8875
8876 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj = 0;
8878 wxWindow *arg1 = (wxWindow *) NULL ;
8879 wxWindowDisabler *result = 0 ;
8880 void *argp1 = 0 ;
8881 int res1 = 0 ;
8882 PyObject * obj0 = 0 ;
8883 char * kwnames[] = {
8884 (char *) "winToSkip", NULL
8885 };
8886
8887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8888 if (obj0) {
8889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8890 if (!SWIG_IsOK(res1)) {
8891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8892 }
8893 arg1 = reinterpret_cast< wxWindow * >(argp1);
8894 }
8895 {
8896 if (!wxPyCheckForApp()) SWIG_fail;
8897 PyThreadState* __tstate = wxPyBeginAllowThreads();
8898 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8899 wxPyEndAllowThreads(__tstate);
8900 if (PyErr_Occurred()) SWIG_fail;
8901 }
8902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8903 return resultobj;
8904 fail:
8905 return NULL;
8906 }
8907
8908
8909 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8910 PyObject *resultobj = 0;
8911 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 PyObject *swig_obj[1] ;
8915
8916 if (!args) SWIG_fail;
8917 swig_obj[0] = args;
8918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8919 if (!SWIG_IsOK(res1)) {
8920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8921 }
8922 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8923 {
8924 PyThreadState* __tstate = wxPyBeginAllowThreads();
8925 delete arg1;
8926
8927 wxPyEndAllowThreads(__tstate);
8928 if (PyErr_Occurred()) SWIG_fail;
8929 }
8930 resultobj = SWIG_Py_Void();
8931 return resultobj;
8932 fail:
8933 return NULL;
8934 }
8935
8936
8937 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8938 PyObject *obj;
8939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8940 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8941 return SWIG_Py_Void();
8942 }
8943
8944 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8945 return SWIG_Python_InitShadowInstance(args);
8946 }
8947
8948 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8949 PyObject *resultobj = 0;
8950 wxString *arg1 = 0 ;
8951 wxBusyInfo *result = 0 ;
8952 bool temp1 = false ;
8953 PyObject * obj0 = 0 ;
8954 char * kwnames[] = {
8955 (char *) "message", NULL
8956 };
8957
8958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8959 {
8960 arg1 = wxString_in_helper(obj0);
8961 if (arg1 == NULL) SWIG_fail;
8962 temp1 = true;
8963 }
8964 {
8965 if (!wxPyCheckForApp()) SWIG_fail;
8966 PyThreadState* __tstate = wxPyBeginAllowThreads();
8967 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8968 wxPyEndAllowThreads(__tstate);
8969 if (PyErr_Occurred()) SWIG_fail;
8970 }
8971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8972 {
8973 if (temp1)
8974 delete arg1;
8975 }
8976 return resultobj;
8977 fail:
8978 {
8979 if (temp1)
8980 delete arg1;
8981 }
8982 return NULL;
8983 }
8984
8985
8986 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8987 PyObject *resultobj = 0;
8988 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
8989 void *argp1 = 0 ;
8990 int res1 = 0 ;
8991 PyObject *swig_obj[1] ;
8992
8993 if (!args) SWIG_fail;
8994 swig_obj[0] = args;
8995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
8996 if (!SWIG_IsOK(res1)) {
8997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
8998 }
8999 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9000 {
9001 PyThreadState* __tstate = wxPyBeginAllowThreads();
9002 delete arg1;
9003
9004 wxPyEndAllowThreads(__tstate);
9005 if (PyErr_Occurred()) SWIG_fail;
9006 }
9007 resultobj = SWIG_Py_Void();
9008 return resultobj;
9009 fail:
9010 return NULL;
9011 }
9012
9013
9014 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9015 PyObject *obj;
9016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9017 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9018 return SWIG_Py_Void();
9019 }
9020
9021 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9022 return SWIG_Python_InitShadowInstance(args);
9023 }
9024
9025 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9026 PyObject *resultobj = 0;
9027 wxStopWatch *result = 0 ;
9028
9029 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9030 {
9031 PyThreadState* __tstate = wxPyBeginAllowThreads();
9032 result = (wxStopWatch *)new wxStopWatch();
9033 wxPyEndAllowThreads(__tstate);
9034 if (PyErr_Occurred()) SWIG_fail;
9035 }
9036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj = 0;
9045 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9046 long arg2 = (long) 0 ;
9047 void *argp1 = 0 ;
9048 int res1 = 0 ;
9049 long val2 ;
9050 int ecode2 = 0 ;
9051 PyObject * obj0 = 0 ;
9052 PyObject * obj1 = 0 ;
9053 char * kwnames[] = {
9054 (char *) "self",(char *) "t0", NULL
9055 };
9056
9057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9061 }
9062 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9063 if (obj1) {
9064 ecode2 = SWIG_AsVal_long(obj1, &val2);
9065 if (!SWIG_IsOK(ecode2)) {
9066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9067 }
9068 arg2 = static_cast< long >(val2);
9069 }
9070 {
9071 PyThreadState* __tstate = wxPyBeginAllowThreads();
9072 (arg1)->Start(arg2);
9073 wxPyEndAllowThreads(__tstate);
9074 if (PyErr_Occurred()) SWIG_fail;
9075 }
9076 resultobj = SWIG_Py_Void();
9077 return resultobj;
9078 fail:
9079 return NULL;
9080 }
9081
9082
9083 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9084 PyObject *resultobj = 0;
9085 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9086 void *argp1 = 0 ;
9087 int res1 = 0 ;
9088 PyObject *swig_obj[1] ;
9089
9090 if (!args) SWIG_fail;
9091 swig_obj[0] = args;
9092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9093 if (!SWIG_IsOK(res1)) {
9094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9095 }
9096 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 (arg1)->Pause();
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 resultobj = SWIG_Py_Void();
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9111 PyObject *resultobj = 0;
9112 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9113 void *argp1 = 0 ;
9114 int res1 = 0 ;
9115 PyObject *swig_obj[1] ;
9116
9117 if (!args) SWIG_fail;
9118 swig_obj[0] = args;
9119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9120 if (!SWIG_IsOK(res1)) {
9121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9122 }
9123 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9124 {
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 (arg1)->Resume();
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 resultobj = SWIG_Py_Void();
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9138 PyObject *resultobj = 0;
9139 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9140 long result;
9141 void *argp1 = 0 ;
9142 int res1 = 0 ;
9143 PyObject *swig_obj[1] ;
9144
9145 if (!args) SWIG_fail;
9146 swig_obj[0] = args;
9147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9148 if (!SWIG_IsOK(res1)) {
9149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9150 }
9151 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 result = (long)((wxStopWatch const *)arg1)->Time();
9155 wxPyEndAllowThreads(__tstate);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 resultobj = SWIG_From_long(static_cast< long >(result));
9159 return resultobj;
9160 fail:
9161 return NULL;
9162 }
9163
9164
9165 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9166 PyObject *obj;
9167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9168 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9169 return SWIG_Py_Void();
9170 }
9171
9172 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9173 return SWIG_Python_InitShadowInstance(args);
9174 }
9175
9176 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj = 0;
9178 int arg1 = (int) 9 ;
9179 int arg2 = (int) wxID_FILE1 ;
9180 wxFileHistory *result = 0 ;
9181 int val1 ;
9182 int ecode1 = 0 ;
9183 int val2 ;
9184 int ecode2 = 0 ;
9185 PyObject * obj0 = 0 ;
9186 PyObject * obj1 = 0 ;
9187 char * kwnames[] = {
9188 (char *) "maxFiles",(char *) "idBase", NULL
9189 };
9190
9191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9192 if (obj0) {
9193 ecode1 = SWIG_AsVal_int(obj0, &val1);
9194 if (!SWIG_IsOK(ecode1)) {
9195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9196 }
9197 arg1 = static_cast< int >(val1);
9198 }
9199 if (obj1) {
9200 ecode2 = SWIG_AsVal_int(obj1, &val2);
9201 if (!SWIG_IsOK(ecode2)) {
9202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9203 }
9204 arg2 = static_cast< int >(val2);
9205 }
9206 {
9207 PyThreadState* __tstate = wxPyBeginAllowThreads();
9208 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9209 wxPyEndAllowThreads(__tstate);
9210 if (PyErr_Occurred()) SWIG_fail;
9211 }
9212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9213 return resultobj;
9214 fail:
9215 return NULL;
9216 }
9217
9218
9219 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9220 PyObject *resultobj = 0;
9221 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9222 void *argp1 = 0 ;
9223 int res1 = 0 ;
9224 PyObject *swig_obj[1] ;
9225
9226 if (!args) SWIG_fail;
9227 swig_obj[0] = args;
9228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9231 }
9232 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 delete arg1;
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 resultobj = SWIG_Py_Void();
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9248 PyObject *resultobj = 0;
9249 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9250 wxString *arg2 = 0 ;
9251 void *argp1 = 0 ;
9252 int res1 = 0 ;
9253 bool temp2 = false ;
9254 PyObject * obj0 = 0 ;
9255 PyObject * obj1 = 0 ;
9256 char * kwnames[] = {
9257 (char *) "self",(char *) "file", NULL
9258 };
9259
9260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9262 if (!SWIG_IsOK(res1)) {
9263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9264 }
9265 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9266 {
9267 arg2 = wxString_in_helper(obj1);
9268 if (arg2 == NULL) SWIG_fail;
9269 temp2 = true;
9270 }
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 (arg1)->AddFileToHistory((wxString const &)*arg2);
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_Py_Void();
9278 {
9279 if (temp2)
9280 delete arg2;
9281 }
9282 return resultobj;
9283 fail:
9284 {
9285 if (temp2)
9286 delete arg2;
9287 }
9288 return NULL;
9289 }
9290
9291
9292 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9293 PyObject *resultobj = 0;
9294 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9295 int arg2 ;
9296 void *argp1 = 0 ;
9297 int res1 = 0 ;
9298 int val2 ;
9299 int ecode2 = 0 ;
9300 PyObject * obj0 = 0 ;
9301 PyObject * obj1 = 0 ;
9302 char * kwnames[] = {
9303 (char *) "self",(char *) "i", NULL
9304 };
9305
9306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9308 if (!SWIG_IsOK(res1)) {
9309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9310 }
9311 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9312 ecode2 = SWIG_AsVal_int(obj1, &val2);
9313 if (!SWIG_IsOK(ecode2)) {
9314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9315 }
9316 arg2 = static_cast< int >(val2);
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 (arg1)->RemoveFileFromHistory(arg2);
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 resultobj = SWIG_Py_Void();
9324 return resultobj;
9325 fail:
9326 return NULL;
9327 }
9328
9329
9330 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9331 PyObject *resultobj = 0;
9332 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9333 int result;
9334 void *argp1 = 0 ;
9335 int res1 = 0 ;
9336 PyObject *swig_obj[1] ;
9337
9338 if (!args) SWIG_fail;
9339 swig_obj[0] = args;
9340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9341 if (!SWIG_IsOK(res1)) {
9342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9343 }
9344 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9345 {
9346 PyThreadState* __tstate = wxPyBeginAllowThreads();
9347 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9348 wxPyEndAllowThreads(__tstate);
9349 if (PyErr_Occurred()) SWIG_fail;
9350 }
9351 resultobj = SWIG_From_int(static_cast< int >(result));
9352 return resultobj;
9353 fail:
9354 return NULL;
9355 }
9356
9357
9358 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9359 PyObject *resultobj = 0;
9360 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9361 wxMenu *arg2 = (wxMenu *) 0 ;
9362 void *argp1 = 0 ;
9363 int res1 = 0 ;
9364 void *argp2 = 0 ;
9365 int res2 = 0 ;
9366 PyObject * obj0 = 0 ;
9367 PyObject * obj1 = 0 ;
9368 char * kwnames[] = {
9369 (char *) "self",(char *) "menu", NULL
9370 };
9371
9372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9374 if (!SWIG_IsOK(res1)) {
9375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9376 }
9377 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9379 if (!SWIG_IsOK(res2)) {
9380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9381 }
9382 arg2 = reinterpret_cast< wxMenu * >(argp2);
9383 {
9384 PyThreadState* __tstate = wxPyBeginAllowThreads();
9385 (arg1)->UseMenu(arg2);
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 resultobj = SWIG_Py_Void();
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj = 0;
9398 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9399 wxMenu *arg2 = (wxMenu *) 0 ;
9400 void *argp1 = 0 ;
9401 int res1 = 0 ;
9402 void *argp2 = 0 ;
9403 int res2 = 0 ;
9404 PyObject * obj0 = 0 ;
9405 PyObject * obj1 = 0 ;
9406 char * kwnames[] = {
9407 (char *) "self",(char *) "menu", NULL
9408 };
9409
9410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",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_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9414 }
9415 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9417 if (!SWIG_IsOK(res2)) {
9418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9419 }
9420 arg2 = reinterpret_cast< wxMenu * >(argp2);
9421 {
9422 PyThreadState* __tstate = wxPyBeginAllowThreads();
9423 (arg1)->RemoveMenu(arg2);
9424 wxPyEndAllowThreads(__tstate);
9425 if (PyErr_Occurred()) SWIG_fail;
9426 }
9427 resultobj = SWIG_Py_Void();
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj = 0;
9436 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9437 wxConfigBase *arg2 = 0 ;
9438 void *argp1 = 0 ;
9439 int res1 = 0 ;
9440 void *argp2 = 0 ;
9441 int res2 = 0 ;
9442 PyObject * obj0 = 0 ;
9443 PyObject * obj1 = 0 ;
9444 char * kwnames[] = {
9445 (char *) "self",(char *) "config", NULL
9446 };
9447
9448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9450 if (!SWIG_IsOK(res1)) {
9451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9452 }
9453 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9455 if (!SWIG_IsOK(res2)) {
9456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9457 }
9458 if (!argp2) {
9459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9460 }
9461 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 (arg1)->Load(*arg2);
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 resultobj = SWIG_Py_Void();
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9476 PyObject *resultobj = 0;
9477 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9478 wxConfigBase *arg2 = 0 ;
9479 void *argp1 = 0 ;
9480 int res1 = 0 ;
9481 void *argp2 = 0 ;
9482 int res2 = 0 ;
9483 PyObject * obj0 = 0 ;
9484 PyObject * obj1 = 0 ;
9485 char * kwnames[] = {
9486 (char *) "self",(char *) "config", NULL
9487 };
9488
9489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9491 if (!SWIG_IsOK(res1)) {
9492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9493 }
9494 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9495 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9496 if (!SWIG_IsOK(res2)) {
9497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9498 }
9499 if (!argp2) {
9500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9501 }
9502 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9503 {
9504 PyThreadState* __tstate = wxPyBeginAllowThreads();
9505 (arg1)->Save(*arg2);
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_Py_Void();
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9517 PyObject *resultobj = 0;
9518 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9519 void *argp1 = 0 ;
9520 int res1 = 0 ;
9521 PyObject *swig_obj[1] ;
9522
9523 if (!args) SWIG_fail;
9524 swig_obj[0] = args;
9525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9526 if (!SWIG_IsOK(res1)) {
9527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9528 }
9529 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 (arg1)->AddFilesToMenu();
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 resultobj = SWIG_Py_Void();
9537 return resultobj;
9538 fail:
9539 return NULL;
9540 }
9541
9542
9543 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj = 0;
9545 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9546 wxMenu *arg2 = (wxMenu *) 0 ;
9547 void *argp1 = 0 ;
9548 int res1 = 0 ;
9549 void *argp2 = 0 ;
9550 int res2 = 0 ;
9551 PyObject * obj0 = 0 ;
9552 PyObject * obj1 = 0 ;
9553 char * kwnames[] = {
9554 (char *) "self",(char *) "menu", NULL
9555 };
9556
9557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9559 if (!SWIG_IsOK(res1)) {
9560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9561 }
9562 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9563 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9564 if (!SWIG_IsOK(res2)) {
9565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9566 }
9567 arg2 = reinterpret_cast< wxMenu * >(argp2);
9568 {
9569 PyThreadState* __tstate = wxPyBeginAllowThreads();
9570 (arg1)->AddFilesToMenu(arg2);
9571 wxPyEndAllowThreads(__tstate);
9572 if (PyErr_Occurred()) SWIG_fail;
9573 }
9574 resultobj = SWIG_Py_Void();
9575 return resultobj;
9576 fail:
9577 return NULL;
9578 }
9579
9580
9581 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9582 PyObject *resultobj = 0;
9583 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9584 int arg2 ;
9585 wxString result;
9586 void *argp1 = 0 ;
9587 int res1 = 0 ;
9588 int val2 ;
9589 int ecode2 = 0 ;
9590 PyObject * obj0 = 0 ;
9591 PyObject * obj1 = 0 ;
9592 char * kwnames[] = {
9593 (char *) "self",(char *) "i", NULL
9594 };
9595
9596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9598 if (!SWIG_IsOK(res1)) {
9599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9600 }
9601 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9602 ecode2 = SWIG_AsVal_int(obj1, &val2);
9603 if (!SWIG_IsOK(ecode2)) {
9604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9605 }
9606 arg2 = static_cast< int >(val2);
9607 {
9608 PyThreadState* __tstate = wxPyBeginAllowThreads();
9609 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9610 wxPyEndAllowThreads(__tstate);
9611 if (PyErr_Occurred()) SWIG_fail;
9612 }
9613 {
9614 #if wxUSE_UNICODE
9615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9616 #else
9617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9618 #endif
9619 }
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9627 PyObject *resultobj = 0;
9628 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9629 int result;
9630 void *argp1 = 0 ;
9631 int res1 = 0 ;
9632 PyObject *swig_obj[1] ;
9633
9634 if (!args) SWIG_fail;
9635 swig_obj[0] = args;
9636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9637 if (!SWIG_IsOK(res1)) {
9638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9639 }
9640 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9641 {
9642 PyThreadState* __tstate = wxPyBeginAllowThreads();
9643 result = (int)((wxFileHistory const *)arg1)->GetCount();
9644 wxPyEndAllowThreads(__tstate);
9645 if (PyErr_Occurred()) SWIG_fail;
9646 }
9647 resultobj = SWIG_From_int(static_cast< int >(result));
9648 return resultobj;
9649 fail:
9650 return NULL;
9651 }
9652
9653
9654 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9655 PyObject *obj;
9656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9657 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9658 return SWIG_Py_Void();
9659 }
9660
9661 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9662 return SWIG_Python_InitShadowInstance(args);
9663 }
9664
9665 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9666 PyObject *resultobj = 0;
9667 wxString *arg1 = 0 ;
9668 wxString const &arg2_defvalue = wxPyEmptyString ;
9669 wxString *arg2 = (wxString *) &arg2_defvalue ;
9670 wxSingleInstanceChecker *result = 0 ;
9671 bool temp1 = false ;
9672 bool temp2 = false ;
9673 PyObject * obj0 = 0 ;
9674 PyObject * obj1 = 0 ;
9675 char * kwnames[] = {
9676 (char *) "name",(char *) "path", NULL
9677 };
9678
9679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9680 {
9681 arg1 = wxString_in_helper(obj0);
9682 if (arg1 == NULL) SWIG_fail;
9683 temp1 = true;
9684 }
9685 if (obj1) {
9686 {
9687 arg2 = wxString_in_helper(obj1);
9688 if (arg2 == NULL) SWIG_fail;
9689 temp2 = true;
9690 }
9691 }
9692 {
9693 PyThreadState* __tstate = wxPyBeginAllowThreads();
9694 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9695 wxPyEndAllowThreads(__tstate);
9696 if (PyErr_Occurred()) SWIG_fail;
9697 }
9698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9699 {
9700 if (temp1)
9701 delete arg1;
9702 }
9703 {
9704 if (temp2)
9705 delete arg2;
9706 }
9707 return resultobj;
9708 fail:
9709 {
9710 if (temp1)
9711 delete arg1;
9712 }
9713 {
9714 if (temp2)
9715 delete arg2;
9716 }
9717 return NULL;
9718 }
9719
9720
9721 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9722 PyObject *resultobj = 0;
9723 wxSingleInstanceChecker *result = 0 ;
9724
9725 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9726 {
9727 PyThreadState* __tstate = wxPyBeginAllowThreads();
9728 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9729 wxPyEndAllowThreads(__tstate);
9730 if (PyErr_Occurred()) SWIG_fail;
9731 }
9732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9733 return resultobj;
9734 fail:
9735 return NULL;
9736 }
9737
9738
9739 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9740 PyObject *resultobj = 0;
9741 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9742 void *argp1 = 0 ;
9743 int res1 = 0 ;
9744 PyObject *swig_obj[1] ;
9745
9746 if (!args) SWIG_fail;
9747 swig_obj[0] = args;
9748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9749 if (!SWIG_IsOK(res1)) {
9750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9751 }
9752 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9753 {
9754 PyThreadState* __tstate = wxPyBeginAllowThreads();
9755 delete arg1;
9756
9757 wxPyEndAllowThreads(__tstate);
9758 if (PyErr_Occurred()) SWIG_fail;
9759 }
9760 resultobj = SWIG_Py_Void();
9761 return resultobj;
9762 fail:
9763 return NULL;
9764 }
9765
9766
9767 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9768 PyObject *resultobj = 0;
9769 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9770 wxString *arg2 = 0 ;
9771 wxString const &arg3_defvalue = wxPyEmptyString ;
9772 wxString *arg3 = (wxString *) &arg3_defvalue ;
9773 bool result;
9774 void *argp1 = 0 ;
9775 int res1 = 0 ;
9776 bool temp2 = false ;
9777 bool temp3 = false ;
9778 PyObject * obj0 = 0 ;
9779 PyObject * obj1 = 0 ;
9780 PyObject * obj2 = 0 ;
9781 char * kwnames[] = {
9782 (char *) "self",(char *) "name",(char *) "path", NULL
9783 };
9784
9785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9789 }
9790 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9791 {
9792 arg2 = wxString_in_helper(obj1);
9793 if (arg2 == NULL) SWIG_fail;
9794 temp2 = true;
9795 }
9796 if (obj2) {
9797 {
9798 arg3 = wxString_in_helper(obj2);
9799 if (arg3 == NULL) SWIG_fail;
9800 temp3 = true;
9801 }
9802 }
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 {
9810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9811 }
9812 {
9813 if (temp2)
9814 delete arg2;
9815 }
9816 {
9817 if (temp3)
9818 delete arg3;
9819 }
9820 return resultobj;
9821 fail:
9822 {
9823 if (temp2)
9824 delete arg2;
9825 }
9826 {
9827 if (temp3)
9828 delete arg3;
9829 }
9830 return NULL;
9831 }
9832
9833
9834 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9835 PyObject *resultobj = 0;
9836 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9837 bool result;
9838 void *argp1 = 0 ;
9839 int res1 = 0 ;
9840 PyObject *swig_obj[1] ;
9841
9842 if (!args) SWIG_fail;
9843 swig_obj[0] = args;
9844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9845 if (!SWIG_IsOK(res1)) {
9846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9847 }
9848 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9852 wxPyEndAllowThreads(__tstate);
9853 if (PyErr_Occurred()) SWIG_fail;
9854 }
9855 {
9856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9865 PyObject *obj;
9866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9867 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9868 return SWIG_Py_Void();
9869 }
9870
9871 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9872 return SWIG_Python_InitShadowInstance(args);
9873 }
9874
9875 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9876 PyObject *resultobj = 0;
9877 wxWindow *arg1 = (wxWindow *) 0 ;
9878 wxDC *arg2 = 0 ;
9879 bool result;
9880 void *argp1 = 0 ;
9881 int res1 = 0 ;
9882 void *argp2 = 0 ;
9883 int res2 = 0 ;
9884 PyObject * obj0 = 0 ;
9885 PyObject * obj1 = 0 ;
9886 char * kwnames[] = {
9887 (char *) "window",(char *) "dc", NULL
9888 };
9889
9890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9894 }
9895 arg1 = reinterpret_cast< wxWindow * >(argp1);
9896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9897 if (!SWIG_IsOK(res2)) {
9898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9899 }
9900 if (!argp2) {
9901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9902 }
9903 arg2 = reinterpret_cast< wxDC * >(argp2);
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 {
9911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9912 }
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9920 PyObject *resultobj = 0;
9921 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9922 void *argp1 = 0 ;
9923 int res1 = 0 ;
9924 PyObject *swig_obj[1] ;
9925
9926 if (!args) SWIG_fail;
9927 swig_obj[0] = args;
9928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9931 }
9932 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 delete arg1;
9936
9937 wxPyEndAllowThreads(__tstate);
9938 if (PyErr_Occurred()) SWIG_fail;
9939 }
9940 resultobj = SWIG_Py_Void();
9941 return resultobj;
9942 fail:
9943 return NULL;
9944 }
9945
9946
9947 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9948 PyObject *resultobj = 0;
9949 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9950 wxString result;
9951 void *argp1 = 0 ;
9952 int res1 = 0 ;
9953 PyObject *swig_obj[1] ;
9954
9955 if (!args) SWIG_fail;
9956 swig_obj[0] = args;
9957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9958 if (!SWIG_IsOK(res1)) {
9959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9960 }
9961 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9962 {
9963 PyThreadState* __tstate = wxPyBeginAllowThreads();
9964 result = (arg1)->GetTip();
9965 wxPyEndAllowThreads(__tstate);
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 {
9969 #if wxUSE_UNICODE
9970 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9971 #else
9972 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9973 #endif
9974 }
9975 return resultobj;
9976 fail:
9977 return NULL;
9978 }
9979
9980
9981 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9982 PyObject *resultobj = 0;
9983 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9984 size_t result;
9985 void *argp1 = 0 ;
9986 int res1 = 0 ;
9987 PyObject *swig_obj[1] ;
9988
9989 if (!args) SWIG_fail;
9990 swig_obj[0] = args;
9991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9992 if (!SWIG_IsOK(res1)) {
9993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9994 }
9995 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (size_t)(arg1)->GetCurrentTip();
9999 wxPyEndAllowThreads(__tstate);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10012 wxString *arg2 = 0 ;
10013 wxString result;
10014 void *argp1 = 0 ;
10015 int res1 = 0 ;
10016 bool temp2 = false ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 char * kwnames[] = {
10020 (char *) "self",(char *) "tip", NULL
10021 };
10022
10023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10025 if (!SWIG_IsOK(res1)) {
10026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10027 }
10028 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10029 {
10030 arg2 = wxString_in_helper(obj1);
10031 if (arg2 == NULL) SWIG_fail;
10032 temp2 = true;
10033 }
10034 {
10035 PyThreadState* __tstate = wxPyBeginAllowThreads();
10036 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10037 wxPyEndAllowThreads(__tstate);
10038 if (PyErr_Occurred()) SWIG_fail;
10039 }
10040 {
10041 #if wxUSE_UNICODE
10042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10043 #else
10044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10045 #endif
10046 }
10047 {
10048 if (temp2)
10049 delete arg2;
10050 }
10051 return resultobj;
10052 fail:
10053 {
10054 if (temp2)
10055 delete arg2;
10056 }
10057 return NULL;
10058 }
10059
10060
10061 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10062 PyObject *obj;
10063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10064 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10065 return SWIG_Py_Void();
10066 }
10067
10068 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 size_t arg1 ;
10071 wxPyTipProvider *result = 0 ;
10072 size_t val1 ;
10073 int ecode1 = 0 ;
10074 PyObject * obj0 = 0 ;
10075 char * kwnames[] = {
10076 (char *) "currentTip", NULL
10077 };
10078
10079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10080 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10081 if (!SWIG_IsOK(ecode1)) {
10082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10083 }
10084 arg1 = static_cast< size_t >(val1);
10085 {
10086 PyThreadState* __tstate = wxPyBeginAllowThreads();
10087 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10088 wxPyEndAllowThreads(__tstate);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10099 PyObject *resultobj = 0;
10100 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10101 PyObject *arg2 = (PyObject *) 0 ;
10102 PyObject *arg3 = (PyObject *) 0 ;
10103 void *argp1 = 0 ;
10104 int res1 = 0 ;
10105 PyObject * obj0 = 0 ;
10106 PyObject * obj1 = 0 ;
10107 PyObject * obj2 = 0 ;
10108 char * kwnames[] = {
10109 (char *) "self",(char *) "self",(char *) "_class", NULL
10110 };
10111
10112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10114 if (!SWIG_IsOK(res1)) {
10115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10116 }
10117 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10118 arg2 = obj1;
10119 arg3 = obj2;
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 (arg1)->_setCallbackInfo(arg2,arg3);
10123 wxPyEndAllowThreads(__tstate);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 resultobj = SWIG_Py_Void();
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10134 PyObject *obj;
10135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10136 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10137 return SWIG_Py_Void();
10138 }
10139
10140 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141 return SWIG_Python_InitShadowInstance(args);
10142 }
10143
10144 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10145 PyObject *resultobj = 0;
10146 wxWindow *arg1 = (wxWindow *) 0 ;
10147 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10148 bool arg3 = (bool) true ;
10149 bool result;
10150 void *argp1 = 0 ;
10151 int res1 = 0 ;
10152 void *argp2 = 0 ;
10153 int res2 = 0 ;
10154 bool val3 ;
10155 int ecode3 = 0 ;
10156 PyObject * obj0 = 0 ;
10157 PyObject * obj1 = 0 ;
10158 PyObject * obj2 = 0 ;
10159 char * kwnames[] = {
10160 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10161 };
10162
10163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10165 if (!SWIG_IsOK(res1)) {
10166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10167 }
10168 arg1 = reinterpret_cast< wxWindow * >(argp1);
10169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10170 if (!SWIG_IsOK(res2)) {
10171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10172 }
10173 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10174 if (obj2) {
10175 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10176 if (!SWIG_IsOK(ecode3)) {
10177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10178 }
10179 arg3 = static_cast< bool >(val3);
10180 }
10181 {
10182 if (!wxPyCheckForApp()) SWIG_fail;
10183 PyThreadState* __tstate = wxPyBeginAllowThreads();
10184 result = (bool)wxShowTip(arg1,arg2,arg3);
10185 wxPyEndAllowThreads(__tstate);
10186 if (PyErr_Occurred()) SWIG_fail;
10187 }
10188 {
10189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10190 }
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxString *arg1 = 0 ;
10200 size_t arg2 ;
10201 wxTipProvider *result = 0 ;
10202 bool temp1 = false ;
10203 size_t val2 ;
10204 int ecode2 = 0 ;
10205 PyObject * obj0 = 0 ;
10206 PyObject * obj1 = 0 ;
10207 char * kwnames[] = {
10208 (char *) "filename",(char *) "currentTip", NULL
10209 };
10210
10211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10212 {
10213 arg1 = wxString_in_helper(obj0);
10214 if (arg1 == NULL) SWIG_fail;
10215 temp1 = true;
10216 }
10217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10218 if (!SWIG_IsOK(ecode2)) {
10219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10220 }
10221 arg2 = static_cast< size_t >(val2);
10222 {
10223 if (!wxPyCheckForApp()) SWIG_fail;
10224 PyThreadState* __tstate = wxPyBeginAllowThreads();
10225 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10226 wxPyEndAllowThreads(__tstate);
10227 if (PyErr_Occurred()) SWIG_fail;
10228 }
10229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10230 {
10231 if (temp1)
10232 delete arg1;
10233 }
10234 return resultobj;
10235 fail:
10236 {
10237 if (temp1)
10238 delete arg1;
10239 }
10240 return NULL;
10241 }
10242
10243
10244 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10245 PyObject *resultobj = 0;
10246 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10247 int arg2 = (int) wxID_ANY ;
10248 wxPyTimer *result = 0 ;
10249 void *argp1 = 0 ;
10250 int res1 = 0 ;
10251 int val2 ;
10252 int ecode2 = 0 ;
10253 PyObject * obj0 = 0 ;
10254 PyObject * obj1 = 0 ;
10255 char * kwnames[] = {
10256 (char *) "owner",(char *) "id", NULL
10257 };
10258
10259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10260 if (obj0) {
10261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10262 if (!SWIG_IsOK(res1)) {
10263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10264 }
10265 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10266 }
10267 if (obj1) {
10268 ecode2 = SWIG_AsVal_int(obj1, &val2);
10269 if (!SWIG_IsOK(ecode2)) {
10270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10271 }
10272 arg2 = static_cast< int >(val2);
10273 }
10274 {
10275 if (!wxPyCheckForApp()) SWIG_fail;
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10282 return resultobj;
10283 fail:
10284 return NULL;
10285 }
10286
10287
10288 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10289 PyObject *resultobj = 0;
10290 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10291 void *argp1 = 0 ;
10292 int res1 = 0 ;
10293 PyObject *swig_obj[1] ;
10294
10295 if (!args) SWIG_fail;
10296 swig_obj[0] = args;
10297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10298 if (!SWIG_IsOK(res1)) {
10299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10300 }
10301 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10302 {
10303 PyThreadState* __tstate = wxPyBeginAllowThreads();
10304 delete arg1;
10305
10306 wxPyEndAllowThreads(__tstate);
10307 if (PyErr_Occurred()) SWIG_fail;
10308 }
10309 resultobj = SWIG_Py_Void();
10310 return resultobj;
10311 fail:
10312 return NULL;
10313 }
10314
10315
10316 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10317 PyObject *resultobj = 0;
10318 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10319 PyObject *arg2 = (PyObject *) 0 ;
10320 PyObject *arg3 = (PyObject *) 0 ;
10321 int arg4 = (int) 1 ;
10322 void *argp1 = 0 ;
10323 int res1 = 0 ;
10324 int val4 ;
10325 int ecode4 = 0 ;
10326 PyObject * obj0 = 0 ;
10327 PyObject * obj1 = 0 ;
10328 PyObject * obj2 = 0 ;
10329 PyObject * obj3 = 0 ;
10330 char * kwnames[] = {
10331 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10332 };
10333
10334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10336 if (!SWIG_IsOK(res1)) {
10337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10338 }
10339 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10340 arg2 = obj1;
10341 arg3 = obj2;
10342 if (obj3) {
10343 ecode4 = SWIG_AsVal_int(obj3, &val4);
10344 if (!SWIG_IsOK(ecode4)) {
10345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10346 }
10347 arg4 = static_cast< int >(val4);
10348 }
10349 {
10350 PyThreadState* __tstate = wxPyBeginAllowThreads();
10351 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10352 wxPyEndAllowThreads(__tstate);
10353 if (PyErr_Occurred()) SWIG_fail;
10354 }
10355 resultobj = SWIG_Py_Void();
10356 return resultobj;
10357 fail:
10358 return NULL;
10359 }
10360
10361
10362 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10363 PyObject *resultobj = 0;
10364 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10365 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10366 int arg3 = (int) wxID_ANY ;
10367 void *argp1 = 0 ;
10368 int res1 = 0 ;
10369 void *argp2 = 0 ;
10370 int res2 = 0 ;
10371 int val3 ;
10372 int ecode3 = 0 ;
10373 PyObject * obj0 = 0 ;
10374 PyObject * obj1 = 0 ;
10375 PyObject * obj2 = 0 ;
10376 char * kwnames[] = {
10377 (char *) "self",(char *) "owner",(char *) "id", NULL
10378 };
10379
10380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10384 }
10385 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10387 if (!SWIG_IsOK(res2)) {
10388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10389 }
10390 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10391 if (obj2) {
10392 ecode3 = SWIG_AsVal_int(obj2, &val3);
10393 if (!SWIG_IsOK(ecode3)) {
10394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10395 }
10396 arg3 = static_cast< int >(val3);
10397 }
10398 {
10399 PyThreadState* __tstate = wxPyBeginAllowThreads();
10400 (arg1)->SetOwner(arg2,arg3);
10401 wxPyEndAllowThreads(__tstate);
10402 if (PyErr_Occurred()) SWIG_fail;
10403 }
10404 resultobj = SWIG_Py_Void();
10405 return resultobj;
10406 fail:
10407 return NULL;
10408 }
10409
10410
10411 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10412 PyObject *resultobj = 0;
10413 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10414 wxEvtHandler *result = 0 ;
10415 void *argp1 = 0 ;
10416 int res1 = 0 ;
10417 PyObject *swig_obj[1] ;
10418
10419 if (!args) SWIG_fail;
10420 swig_obj[0] = args;
10421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10422 if (!SWIG_IsOK(res1)) {
10423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10424 }
10425 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10426 {
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 result = (wxEvtHandler *)(arg1)->GetOwner();
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 {
10433 resultobj = wxPyMake_wxObject(result, 0);
10434 }
10435 return resultobj;
10436 fail:
10437 return NULL;
10438 }
10439
10440
10441 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10442 PyObject *resultobj = 0;
10443 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10444 int arg2 = (int) -1 ;
10445 bool arg3 = (bool) false ;
10446 bool result;
10447 void *argp1 = 0 ;
10448 int res1 = 0 ;
10449 int val2 ;
10450 int ecode2 = 0 ;
10451 bool val3 ;
10452 int ecode3 = 0 ;
10453 PyObject * obj0 = 0 ;
10454 PyObject * obj1 = 0 ;
10455 PyObject * obj2 = 0 ;
10456 char * kwnames[] = {
10457 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10458 };
10459
10460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10462 if (!SWIG_IsOK(res1)) {
10463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10464 }
10465 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10466 if (obj1) {
10467 ecode2 = SWIG_AsVal_int(obj1, &val2);
10468 if (!SWIG_IsOK(ecode2)) {
10469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10470 }
10471 arg2 = static_cast< int >(val2);
10472 }
10473 if (obj2) {
10474 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10475 if (!SWIG_IsOK(ecode3)) {
10476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10477 }
10478 arg3 = static_cast< bool >(val3);
10479 }
10480 {
10481 PyThreadState* __tstate = wxPyBeginAllowThreads();
10482 result = (bool)(arg1)->Start(arg2,arg3);
10483 wxPyEndAllowThreads(__tstate);
10484 if (PyErr_Occurred()) SWIG_fail;
10485 }
10486 {
10487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10488 }
10489 return resultobj;
10490 fail:
10491 return NULL;
10492 }
10493
10494
10495 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10496 PyObject *resultobj = 0;
10497 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10498 void *argp1 = 0 ;
10499 int res1 = 0 ;
10500 PyObject *swig_obj[1] ;
10501
10502 if (!args) SWIG_fail;
10503 swig_obj[0] = args;
10504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10505 if (!SWIG_IsOK(res1)) {
10506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10507 }
10508 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10509 {
10510 PyThreadState* __tstate = wxPyBeginAllowThreads();
10511 (arg1)->Stop();
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 resultobj = SWIG_Py_Void();
10516 return resultobj;
10517 fail:
10518 return NULL;
10519 }
10520
10521
10522 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10523 PyObject *resultobj = 0;
10524 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10525 void *argp1 = 0 ;
10526 int res1 = 0 ;
10527 PyObject *swig_obj[1] ;
10528
10529 if (!args) SWIG_fail;
10530 swig_obj[0] = args;
10531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10532 if (!SWIG_IsOK(res1)) {
10533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10534 }
10535 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10536 {
10537 PyThreadState* __tstate = wxPyBeginAllowThreads();
10538 (arg1)->Notify();
10539 wxPyEndAllowThreads(__tstate);
10540 if (PyErr_Occurred()) SWIG_fail;
10541 }
10542 resultobj = SWIG_Py_Void();
10543 return resultobj;
10544 fail:
10545 return NULL;
10546 }
10547
10548
10549 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10550 PyObject *resultobj = 0;
10551 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10552 bool result;
10553 void *argp1 = 0 ;
10554 int res1 = 0 ;
10555 PyObject *swig_obj[1] ;
10556
10557 if (!args) SWIG_fail;
10558 swig_obj[0] = args;
10559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10560 if (!SWIG_IsOK(res1)) {
10561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10562 }
10563 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10564 {
10565 PyThreadState* __tstate = wxPyBeginAllowThreads();
10566 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10567 wxPyEndAllowThreads(__tstate);
10568 if (PyErr_Occurred()) SWIG_fail;
10569 }
10570 {
10571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10572 }
10573 return resultobj;
10574 fail:
10575 return NULL;
10576 }
10577
10578
10579 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10580 PyObject *resultobj = 0;
10581 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10582 int result;
10583 void *argp1 = 0 ;
10584 int res1 = 0 ;
10585 PyObject *swig_obj[1] ;
10586
10587 if (!args) SWIG_fail;
10588 swig_obj[0] = args;
10589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10590 if (!SWIG_IsOK(res1)) {
10591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10592 }
10593 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10594 {
10595 PyThreadState* __tstate = wxPyBeginAllowThreads();
10596 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 resultobj = SWIG_From_int(static_cast< int >(result));
10601 return resultobj;
10602 fail:
10603 return NULL;
10604 }
10605
10606
10607 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10608 PyObject *resultobj = 0;
10609 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10610 int result;
10611 void *argp1 = 0 ;
10612 int res1 = 0 ;
10613 PyObject *swig_obj[1] ;
10614
10615 if (!args) SWIG_fail;
10616 swig_obj[0] = args;
10617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10618 if (!SWIG_IsOK(res1)) {
10619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10620 }
10621 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10622 {
10623 PyThreadState* __tstate = wxPyBeginAllowThreads();
10624 result = (int)((wxPyTimer const *)arg1)->GetId();
10625 wxPyEndAllowThreads(__tstate);
10626 if (PyErr_Occurred()) SWIG_fail;
10627 }
10628 resultobj = SWIG_From_int(static_cast< int >(result));
10629 return resultobj;
10630 fail:
10631 return NULL;
10632 }
10633
10634
10635 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10636 PyObject *resultobj = 0;
10637 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10638 bool result;
10639 void *argp1 = 0 ;
10640 int res1 = 0 ;
10641 PyObject *swig_obj[1] ;
10642
10643 if (!args) SWIG_fail;
10644 swig_obj[0] = args;
10645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10646 if (!SWIG_IsOK(res1)) {
10647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10648 }
10649 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10650 {
10651 PyThreadState* __tstate = wxPyBeginAllowThreads();
10652 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10653 wxPyEndAllowThreads(__tstate);
10654 if (PyErr_Occurred()) SWIG_fail;
10655 }
10656 {
10657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10658 }
10659 return resultobj;
10660 fail:
10661 return NULL;
10662 }
10663
10664
10665 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10666 PyObject *obj;
10667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10668 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10669 return SWIG_Py_Void();
10670 }
10671
10672 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10673 return SWIG_Python_InitShadowInstance(args);
10674 }
10675
10676 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10677 PyObject *resultobj = 0;
10678 int arg1 = (int) 0 ;
10679 int arg2 = (int) 0 ;
10680 wxTimerEvent *result = 0 ;
10681 int val1 ;
10682 int ecode1 = 0 ;
10683 int val2 ;
10684 int ecode2 = 0 ;
10685 PyObject * obj0 = 0 ;
10686 PyObject * obj1 = 0 ;
10687 char * kwnames[] = {
10688 (char *) "timerid",(char *) "interval", NULL
10689 };
10690
10691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10692 if (obj0) {
10693 ecode1 = SWIG_AsVal_int(obj0, &val1);
10694 if (!SWIG_IsOK(ecode1)) {
10695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10696 }
10697 arg1 = static_cast< int >(val1);
10698 }
10699 if (obj1) {
10700 ecode2 = SWIG_AsVal_int(obj1, &val2);
10701 if (!SWIG_IsOK(ecode2)) {
10702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10703 }
10704 arg2 = static_cast< int >(val2);
10705 }
10706 {
10707 PyThreadState* __tstate = wxPyBeginAllowThreads();
10708 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10709 wxPyEndAllowThreads(__tstate);
10710 if (PyErr_Occurred()) SWIG_fail;
10711 }
10712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10713 return resultobj;
10714 fail:
10715 return NULL;
10716 }
10717
10718
10719 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10720 PyObject *resultobj = 0;
10721 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10722 int result;
10723 void *argp1 = 0 ;
10724 int res1 = 0 ;
10725 PyObject *swig_obj[1] ;
10726
10727 if (!args) SWIG_fail;
10728 swig_obj[0] = args;
10729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10730 if (!SWIG_IsOK(res1)) {
10731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10732 }
10733 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10734 {
10735 PyThreadState* __tstate = wxPyBeginAllowThreads();
10736 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10737 wxPyEndAllowThreads(__tstate);
10738 if (PyErr_Occurred()) SWIG_fail;
10739 }
10740 resultobj = SWIG_From_int(static_cast< int >(result));
10741 return resultobj;
10742 fail:
10743 return NULL;
10744 }
10745
10746
10747 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10748 PyObject *obj;
10749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10750 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10751 return SWIG_Py_Void();
10752 }
10753
10754 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10755 return SWIG_Python_InitShadowInstance(args);
10756 }
10757
10758 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10759 PyObject *resultobj = 0;
10760 wxTimer *arg1 = 0 ;
10761 wxTimerRunner *result = 0 ;
10762 void *argp1 = 0 ;
10763 int res1 = 0 ;
10764
10765 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10767 if (!SWIG_IsOK(res1)) {
10768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10769 }
10770 if (!argp1) {
10771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10772 }
10773 arg1 = reinterpret_cast< wxTimer * >(argp1);
10774 {
10775 if (!wxPyCheckForApp()) SWIG_fail;
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10778 wxPyEndAllowThreads(__tstate);
10779 if (PyErr_Occurred()) SWIG_fail;
10780 }
10781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10789 PyObject *resultobj = 0;
10790 wxTimer *arg1 = 0 ;
10791 int arg2 ;
10792 bool arg3 = (bool) false ;
10793 wxTimerRunner *result = 0 ;
10794 void *argp1 = 0 ;
10795 int res1 = 0 ;
10796 int val2 ;
10797 int ecode2 = 0 ;
10798 bool val3 ;
10799 int ecode3 = 0 ;
10800
10801 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10803 if (!SWIG_IsOK(res1)) {
10804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10805 }
10806 if (!argp1) {
10807 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10808 }
10809 arg1 = reinterpret_cast< wxTimer * >(argp1);
10810 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10811 if (!SWIG_IsOK(ecode2)) {
10812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10813 }
10814 arg2 = static_cast< int >(val2);
10815 if (swig_obj[2]) {
10816 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10817 if (!SWIG_IsOK(ecode3)) {
10818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10819 }
10820 arg3 = static_cast< bool >(val3);
10821 }
10822 {
10823 if (!wxPyCheckForApp()) SWIG_fail;
10824 PyThreadState* __tstate = wxPyBeginAllowThreads();
10825 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10826 wxPyEndAllowThreads(__tstate);
10827 if (PyErr_Occurred()) SWIG_fail;
10828 }
10829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10837 int argc;
10838 PyObject *argv[4];
10839
10840 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10841 --argc;
10842 if (argc == 1) {
10843 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10844 }
10845 if ((argc >= 2) && (argc <= 3)) {
10846 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10847 }
10848
10849 fail:
10850 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10856 PyObject *resultobj = 0;
10857 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10858 void *argp1 = 0 ;
10859 int res1 = 0 ;
10860 PyObject *swig_obj[1] ;
10861
10862 if (!args) SWIG_fail;
10863 swig_obj[0] = args;
10864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10865 if (!SWIG_IsOK(res1)) {
10866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10867 }
10868 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10869 {
10870 PyThreadState* __tstate = wxPyBeginAllowThreads();
10871 delete arg1;
10872
10873 wxPyEndAllowThreads(__tstate);
10874 if (PyErr_Occurred()) SWIG_fail;
10875 }
10876 resultobj = SWIG_Py_Void();
10877 return resultobj;
10878 fail:
10879 return NULL;
10880 }
10881
10882
10883 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10884 PyObject *resultobj = 0;
10885 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10886 int arg2 ;
10887 bool arg3 = (bool) false ;
10888 void *argp1 = 0 ;
10889 int res1 = 0 ;
10890 int val2 ;
10891 int ecode2 = 0 ;
10892 bool val3 ;
10893 int ecode3 = 0 ;
10894 PyObject * obj0 = 0 ;
10895 PyObject * obj1 = 0 ;
10896 PyObject * obj2 = 0 ;
10897 char * kwnames[] = {
10898 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10899 };
10900
10901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10903 if (!SWIG_IsOK(res1)) {
10904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10905 }
10906 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10907 ecode2 = SWIG_AsVal_int(obj1, &val2);
10908 if (!SWIG_IsOK(ecode2)) {
10909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10910 }
10911 arg2 = static_cast< int >(val2);
10912 if (obj2) {
10913 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10914 if (!SWIG_IsOK(ecode3)) {
10915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10916 }
10917 arg3 = static_cast< bool >(val3);
10918 }
10919 {
10920 PyThreadState* __tstate = wxPyBeginAllowThreads();
10921 (arg1)->Start(arg2,arg3);
10922 wxPyEndAllowThreads(__tstate);
10923 if (PyErr_Occurred()) SWIG_fail;
10924 }
10925 resultobj = SWIG_Py_Void();
10926 return resultobj;
10927 fail:
10928 return NULL;
10929 }
10930
10931
10932 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10933 PyObject *obj;
10934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10935 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10936 return SWIG_Py_Void();
10937 }
10938
10939 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10940 return SWIG_Python_InitShadowInstance(args);
10941 }
10942
10943 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10944 PyObject *resultobj = 0;
10945 wxLog *result = 0 ;
10946
10947 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10948 {
10949 PyThreadState* __tstate = wxPyBeginAllowThreads();
10950 result = (wxLog *)new wxLog();
10951 wxPyEndAllowThreads(__tstate);
10952 if (PyErr_Occurred()) SWIG_fail;
10953 }
10954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10955 return resultobj;
10956 fail:
10957 return NULL;
10958 }
10959
10960
10961 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10962 PyObject *resultobj = 0;
10963 wxLog *arg1 = (wxLog *) 0 ;
10964 void *argp1 = 0 ;
10965 int res1 = 0 ;
10966 PyObject *swig_obj[1] ;
10967
10968 if (!args) SWIG_fail;
10969 swig_obj[0] = args;
10970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10971 if (!SWIG_IsOK(res1)) {
10972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10973 }
10974 arg1 = reinterpret_cast< wxLog * >(argp1);
10975 {
10976 PyThreadState* __tstate = wxPyBeginAllowThreads();
10977 delete arg1;
10978
10979 wxPyEndAllowThreads(__tstate);
10980 if (PyErr_Occurred()) SWIG_fail;
10981 }
10982 resultobj = SWIG_Py_Void();
10983 return resultobj;
10984 fail:
10985 return NULL;
10986 }
10987
10988
10989 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10990 PyObject *resultobj = 0;
10991 bool result;
10992
10993 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 result = (bool)wxLog::IsEnabled();
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 {
11001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11002 }
11003 return resultobj;
11004 fail:
11005 return NULL;
11006 }
11007
11008
11009 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11010 PyObject *resultobj = 0;
11011 bool arg1 = (bool) true ;
11012 bool result;
11013 bool val1 ;
11014 int ecode1 = 0 ;
11015 PyObject * obj0 = 0 ;
11016 char * kwnames[] = {
11017 (char *) "doIt", NULL
11018 };
11019
11020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11021 if (obj0) {
11022 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11023 if (!SWIG_IsOK(ecode1)) {
11024 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11025 }
11026 arg1 = static_cast< bool >(val1);
11027 }
11028 {
11029 PyThreadState* __tstate = wxPyBeginAllowThreads();
11030 result = (bool)wxLog::EnableLogging(arg1);
11031 wxPyEndAllowThreads(__tstate);
11032 if (PyErr_Occurred()) SWIG_fail;
11033 }
11034 {
11035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11036 }
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj = 0;
11045 wxLogLevel arg1 ;
11046 wxChar *arg2 = (wxChar *) 0 ;
11047 time_t arg3 ;
11048 unsigned long val1 ;
11049 int ecode1 = 0 ;
11050 void *argp2 = 0 ;
11051 int res2 = 0 ;
11052 unsigned int val3 ;
11053 int ecode3 = 0 ;
11054 PyObject * obj0 = 0 ;
11055 PyObject * obj1 = 0 ;
11056 PyObject * obj2 = 0 ;
11057 char * kwnames[] = {
11058 (char *) "level",(char *) "szString",(char *) "t", NULL
11059 };
11060
11061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11062 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11063 if (!SWIG_IsOK(ecode1)) {
11064 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11065 }
11066 arg1 = static_cast< wxLogLevel >(val1);
11067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11068 if (!SWIG_IsOK(res2)) {
11069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11070 }
11071 arg2 = reinterpret_cast< wxChar * >(argp2);
11072 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11073 if (!SWIG_IsOK(ecode3)) {
11074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11075 }
11076 arg3 = static_cast< time_t >(val3);
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 resultobj = SWIG_Py_Void();
11084 return resultobj;
11085 fail:
11086 return NULL;
11087 }
11088
11089
11090 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11091 PyObject *resultobj = 0;
11092 wxLog *arg1 = (wxLog *) 0 ;
11093 void *argp1 = 0 ;
11094 int res1 = 0 ;
11095 PyObject *swig_obj[1] ;
11096
11097 if (!args) SWIG_fail;
11098 swig_obj[0] = args;
11099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11100 if (!SWIG_IsOK(res1)) {
11101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11102 }
11103 arg1 = reinterpret_cast< wxLog * >(argp1);
11104 {
11105 PyThreadState* __tstate = wxPyBeginAllowThreads();
11106 (arg1)->Flush();
11107 wxPyEndAllowThreads(__tstate);
11108 if (PyErr_Occurred()) SWIG_fail;
11109 }
11110 resultobj = SWIG_Py_Void();
11111 return resultobj;
11112 fail:
11113 return NULL;
11114 }
11115
11116
11117 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11118 PyObject *resultobj = 0;
11119
11120 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 wxLog::FlushActive();
11124 wxPyEndAllowThreads(__tstate);
11125 if (PyErr_Occurred()) SWIG_fail;
11126 }
11127 resultobj = SWIG_Py_Void();
11128 return resultobj;
11129 fail:
11130 return NULL;
11131 }
11132
11133
11134 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11135 PyObject *resultobj = 0;
11136 wxLog *result = 0 ;
11137
11138 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 result = (wxLog *)wxLog::GetActiveTarget();
11142 wxPyEndAllowThreads(__tstate);
11143 if (PyErr_Occurred()) SWIG_fail;
11144 }
11145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11146 return resultobj;
11147 fail:
11148 return NULL;
11149 }
11150
11151
11152 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj = 0;
11154 wxLog *arg1 = (wxLog *) 0 ;
11155 wxLog *result = 0 ;
11156 int res1 = 0 ;
11157 PyObject * obj0 = 0 ;
11158 char * kwnames[] = {
11159 (char *) "pLogger", NULL
11160 };
11161
11162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11163 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11164 if (!SWIG_IsOK(res1)) {
11165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11166 }
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11170 wxPyEndAllowThreads(__tstate);
11171 if (PyErr_Occurred()) SWIG_fail;
11172 }
11173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11174 return resultobj;
11175 fail:
11176 return NULL;
11177 }
11178
11179
11180 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11181 PyObject *resultobj = 0;
11182
11183 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 wxLog::Suspend();
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 resultobj = SWIG_Py_Void();
11191 return resultobj;
11192 fail:
11193 return NULL;
11194 }
11195
11196
11197 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11198 PyObject *resultobj = 0;
11199
11200 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11201 {
11202 PyThreadState* __tstate = wxPyBeginAllowThreads();
11203 wxLog::Resume();
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 resultobj = SWIG_Py_Void();
11208 return resultobj;
11209 fail:
11210 return NULL;
11211 }
11212
11213
11214 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11215 PyObject *resultobj = 0;
11216 bool arg1 = (bool) true ;
11217 bool val1 ;
11218 int ecode1 = 0 ;
11219 PyObject * obj0 = 0 ;
11220 char * kwnames[] = {
11221 (char *) "bVerbose", NULL
11222 };
11223
11224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11225 if (obj0) {
11226 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11227 if (!SWIG_IsOK(ecode1)) {
11228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11229 }
11230 arg1 = static_cast< bool >(val1);
11231 }
11232 {
11233 PyThreadState* __tstate = wxPyBeginAllowThreads();
11234 wxLog::SetVerbose(arg1);
11235 wxPyEndAllowThreads(__tstate);
11236 if (PyErr_Occurred()) SWIG_fail;
11237 }
11238 resultobj = SWIG_Py_Void();
11239 return resultobj;
11240 fail:
11241 return NULL;
11242 }
11243
11244
11245 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11246 PyObject *resultobj = 0;
11247 wxLogLevel arg1 ;
11248 unsigned long val1 ;
11249 int ecode1 = 0 ;
11250 PyObject * obj0 = 0 ;
11251 char * kwnames[] = {
11252 (char *) "logLevel", NULL
11253 };
11254
11255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11256 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11257 if (!SWIG_IsOK(ecode1)) {
11258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11259 }
11260 arg1 = static_cast< wxLogLevel >(val1);
11261 {
11262 PyThreadState* __tstate = wxPyBeginAllowThreads();
11263 wxLog::SetLogLevel(arg1);
11264 wxPyEndAllowThreads(__tstate);
11265 if (PyErr_Occurred()) SWIG_fail;
11266 }
11267 resultobj = SWIG_Py_Void();
11268 return resultobj;
11269 fail:
11270 return NULL;
11271 }
11272
11273
11274 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11275 PyObject *resultobj = 0;
11276
11277 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11278 {
11279 PyThreadState* __tstate = wxPyBeginAllowThreads();
11280 wxLog::DontCreateOnDemand();
11281 wxPyEndAllowThreads(__tstate);
11282 if (PyErr_Occurred()) SWIG_fail;
11283 }
11284 resultobj = SWIG_Py_Void();
11285 return resultobj;
11286 fail:
11287 return NULL;
11288 }
11289
11290
11291 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11292 PyObject *resultobj = 0;
11293 wxTraceMask arg1 ;
11294 unsigned long val1 ;
11295 int ecode1 = 0 ;
11296 PyObject * obj0 = 0 ;
11297 char * kwnames[] = {
11298 (char *) "ulMask", NULL
11299 };
11300
11301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11302 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11303 if (!SWIG_IsOK(ecode1)) {
11304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11305 }
11306 arg1 = static_cast< wxTraceMask >(val1);
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 wxLog::SetTraceMask(arg1);
11310 wxPyEndAllowThreads(__tstate);
11311 if (PyErr_Occurred()) SWIG_fail;
11312 }
11313 resultobj = SWIG_Py_Void();
11314 return resultobj;
11315 fail:
11316 return NULL;
11317 }
11318
11319
11320 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj = 0;
11322 wxString *arg1 = 0 ;
11323 bool temp1 = false ;
11324 PyObject * obj0 = 0 ;
11325 char * kwnames[] = {
11326 (char *) "str", NULL
11327 };
11328
11329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11330 {
11331 arg1 = wxString_in_helper(obj0);
11332 if (arg1 == NULL) SWIG_fail;
11333 temp1 = true;
11334 }
11335 {
11336 PyThreadState* __tstate = wxPyBeginAllowThreads();
11337 wxLog::AddTraceMask((wxString const &)*arg1);
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 resultobj = SWIG_Py_Void();
11342 {
11343 if (temp1)
11344 delete arg1;
11345 }
11346 return resultobj;
11347 fail:
11348 {
11349 if (temp1)
11350 delete arg1;
11351 }
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxString *arg1 = 0 ;
11359 bool temp1 = false ;
11360 PyObject * obj0 = 0 ;
11361 char * kwnames[] = {
11362 (char *) "str", NULL
11363 };
11364
11365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11366 {
11367 arg1 = wxString_in_helper(obj0);
11368 if (arg1 == NULL) SWIG_fail;
11369 temp1 = true;
11370 }
11371 {
11372 PyThreadState* __tstate = wxPyBeginAllowThreads();
11373 wxLog::RemoveTraceMask((wxString const &)*arg1);
11374 wxPyEndAllowThreads(__tstate);
11375 if (PyErr_Occurred()) SWIG_fail;
11376 }
11377 resultobj = SWIG_Py_Void();
11378 {
11379 if (temp1)
11380 delete arg1;
11381 }
11382 return resultobj;
11383 fail:
11384 {
11385 if (temp1)
11386 delete arg1;
11387 }
11388 return NULL;
11389 }
11390
11391
11392 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11393 PyObject *resultobj = 0;
11394
11395 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11396 {
11397 PyThreadState* __tstate = wxPyBeginAllowThreads();
11398 wxLog::ClearTraceMasks();
11399 wxPyEndAllowThreads(__tstate);
11400 if (PyErr_Occurred()) SWIG_fail;
11401 }
11402 resultobj = SWIG_Py_Void();
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11410 PyObject *resultobj = 0;
11411 wxArrayString *result = 0 ;
11412
11413 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11414 {
11415 PyThreadState* __tstate = wxPyBeginAllowThreads();
11416 {
11417 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11418 result = (wxArrayString *) &_result_ref;
11419 }
11420 wxPyEndAllowThreads(__tstate);
11421 if (PyErr_Occurred()) SWIG_fail;
11422 }
11423 {
11424 resultobj = wxArrayString2PyList_helper(*result);
11425 }
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj = 0;
11434 wxChar *arg1 = (wxChar *) 0 ;
11435 void *argp1 = 0 ;
11436 int res1 = 0 ;
11437 PyObject * obj0 = 0 ;
11438 char * kwnames[] = {
11439 (char *) "ts", NULL
11440 };
11441
11442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11444 if (!SWIG_IsOK(res1)) {
11445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11446 }
11447 arg1 = reinterpret_cast< wxChar * >(argp1);
11448 {
11449 PyThreadState* __tstate = wxPyBeginAllowThreads();
11450 wxLog::SetTimestamp((wxChar const *)arg1);
11451 wxPyEndAllowThreads(__tstate);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 resultobj = SWIG_Py_Void();
11455 return resultobj;
11456 fail:
11457 return NULL;
11458 }
11459
11460
11461 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11462 PyObject *resultobj = 0;
11463 bool result;
11464
11465 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 result = (bool)wxLog::GetVerbose();
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 {
11473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11474 }
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11482 PyObject *resultobj = 0;
11483 wxTraceMask result;
11484
11485 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 result = (wxTraceMask)wxLog::GetTraceMask();
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj = 0;
11501 wxChar *arg1 = (wxChar *) 0 ;
11502 bool result;
11503 void *argp1 = 0 ;
11504 int res1 = 0 ;
11505 PyObject * obj0 = 0 ;
11506 char * kwnames[] = {
11507 (char *) "mask", NULL
11508 };
11509
11510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11512 if (!SWIG_IsOK(res1)) {
11513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11514 }
11515 arg1 = reinterpret_cast< wxChar * >(argp1);
11516 {
11517 PyThreadState* __tstate = wxPyBeginAllowThreads();
11518 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11519 wxPyEndAllowThreads(__tstate);
11520 if (PyErr_Occurred()) SWIG_fail;
11521 }
11522 {
11523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11524 }
11525 return resultobj;
11526 fail:
11527 return NULL;
11528 }
11529
11530
11531 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11532 PyObject *resultobj = 0;
11533 wxLogLevel result;
11534
11535 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11536 {
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 result = (wxLogLevel)wxLog::GetLogLevel();
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11543 return resultobj;
11544 fail:
11545 return NULL;
11546 }
11547
11548
11549 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11550 PyObject *resultobj = 0;
11551 wxChar *result = 0 ;
11552
11553 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11554 {
11555 PyThreadState* __tstate = wxPyBeginAllowThreads();
11556 result = (wxChar *)wxLog::GetTimestamp();
11557 wxPyEndAllowThreads(__tstate);
11558 if (PyErr_Occurred()) SWIG_fail;
11559 }
11560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11561 return resultobj;
11562 fail:
11563 return NULL;
11564 }
11565
11566
11567 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11568 PyObject *resultobj = 0;
11569 wxString result;
11570
11571 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11572 {
11573 PyThreadState* __tstate = wxPyBeginAllowThreads();
11574 result = wxLog_TimeStamp();
11575 wxPyEndAllowThreads(__tstate);
11576 if (PyErr_Occurred()) SWIG_fail;
11577 }
11578 {
11579 #if wxUSE_UNICODE
11580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11581 #else
11582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11583 #endif
11584 }
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11592 PyObject *resultobj = 0;
11593 wxLog *arg1 = (wxLog *) 0 ;
11594 void *argp1 = 0 ;
11595 int res1 = 0 ;
11596 PyObject *swig_obj[1] ;
11597
11598 if (!args) SWIG_fail;
11599 swig_obj[0] = args;
11600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11601 if (!SWIG_IsOK(res1)) {
11602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11603 }
11604 arg1 = reinterpret_cast< wxLog * >(argp1);
11605 {
11606 PyThreadState* __tstate = wxPyBeginAllowThreads();
11607 wxLog_Destroy(arg1);
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 resultobj = SWIG_Py_Void();
11612 return resultobj;
11613 fail:
11614 return NULL;
11615 }
11616
11617
11618 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11619 PyObject *obj;
11620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11621 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11622 return SWIG_Py_Void();
11623 }
11624
11625 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11626 return SWIG_Python_InitShadowInstance(args);
11627 }
11628
11629 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11630 PyObject *resultobj = 0;
11631 wxLogStderr *result = 0 ;
11632
11633 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (wxLogStderr *)new wxLogStderr();
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11641 return resultobj;
11642 fail:
11643 return NULL;
11644 }
11645
11646
11647 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11648 PyObject *obj;
11649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11650 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11651 return SWIG_Py_Void();
11652 }
11653
11654 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11655 return SWIG_Python_InitShadowInstance(args);
11656 }
11657
11658 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11659 PyObject *resultobj = 0;
11660 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11661 wxLogTextCtrl *result = 0 ;
11662 void *argp1 = 0 ;
11663 int res1 = 0 ;
11664 PyObject * obj0 = 0 ;
11665 char * kwnames[] = {
11666 (char *) "pTextCtrl", NULL
11667 };
11668
11669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11671 if (!SWIG_IsOK(res1)) {
11672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11673 }
11674 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11675 {
11676 PyThreadState* __tstate = wxPyBeginAllowThreads();
11677 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11678 wxPyEndAllowThreads(__tstate);
11679 if (PyErr_Occurred()) SWIG_fail;
11680 }
11681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11682 return resultobj;
11683 fail:
11684 return NULL;
11685 }
11686
11687
11688 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11689 PyObject *obj;
11690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11691 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11692 return SWIG_Py_Void();
11693 }
11694
11695 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11696 return SWIG_Python_InitShadowInstance(args);
11697 }
11698
11699 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11700 PyObject *resultobj = 0;
11701 wxLogGui *result = 0 ;
11702
11703 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11704 {
11705 PyThreadState* __tstate = wxPyBeginAllowThreads();
11706 result = (wxLogGui *)new wxLogGui();
11707 wxPyEndAllowThreads(__tstate);
11708 if (PyErr_Occurred()) SWIG_fail;
11709 }
11710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11718 PyObject *obj;
11719 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11720 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11721 return SWIG_Py_Void();
11722 }
11723
11724 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11725 return SWIG_Python_InitShadowInstance(args);
11726 }
11727
11728 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj = 0;
11730 wxFrame *arg1 = (wxFrame *) 0 ;
11731 wxString *arg2 = 0 ;
11732 bool arg3 = (bool) true ;
11733 bool arg4 = (bool) true ;
11734 wxLogWindow *result = 0 ;
11735 void *argp1 = 0 ;
11736 int res1 = 0 ;
11737 bool temp2 = false ;
11738 bool val3 ;
11739 int ecode3 = 0 ;
11740 bool val4 ;
11741 int ecode4 = 0 ;
11742 PyObject * obj0 = 0 ;
11743 PyObject * obj1 = 0 ;
11744 PyObject * obj2 = 0 ;
11745 PyObject * obj3 = 0 ;
11746 char * kwnames[] = {
11747 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11748 };
11749
11750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11752 if (!SWIG_IsOK(res1)) {
11753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11754 }
11755 arg1 = reinterpret_cast< wxFrame * >(argp1);
11756 {
11757 arg2 = wxString_in_helper(obj1);
11758 if (arg2 == NULL) SWIG_fail;
11759 temp2 = true;
11760 }
11761 if (obj2) {
11762 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11763 if (!SWIG_IsOK(ecode3)) {
11764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11765 }
11766 arg3 = static_cast< bool >(val3);
11767 }
11768 if (obj3) {
11769 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11770 if (!SWIG_IsOK(ecode4)) {
11771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11772 }
11773 arg4 = static_cast< bool >(val4);
11774 }
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11782 {
11783 if (temp2)
11784 delete arg2;
11785 }
11786 return resultobj;
11787 fail:
11788 {
11789 if (temp2)
11790 delete arg2;
11791 }
11792 return NULL;
11793 }
11794
11795
11796 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11797 PyObject *resultobj = 0;
11798 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11799 bool arg2 = (bool) true ;
11800 void *argp1 = 0 ;
11801 int res1 = 0 ;
11802 bool val2 ;
11803 int ecode2 = 0 ;
11804 PyObject * obj0 = 0 ;
11805 PyObject * obj1 = 0 ;
11806 char * kwnames[] = {
11807 (char *) "self",(char *) "bShow", NULL
11808 };
11809
11810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11812 if (!SWIG_IsOK(res1)) {
11813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11814 }
11815 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11816 if (obj1) {
11817 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11818 if (!SWIG_IsOK(ecode2)) {
11819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11820 }
11821 arg2 = static_cast< bool >(val2);
11822 }
11823 {
11824 PyThreadState* __tstate = wxPyBeginAllowThreads();
11825 (arg1)->Show(arg2);
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 resultobj = SWIG_Py_Void();
11830 return resultobj;
11831 fail:
11832 return NULL;
11833 }
11834
11835
11836 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11837 PyObject *resultobj = 0;
11838 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11839 wxFrame *result = 0 ;
11840 void *argp1 = 0 ;
11841 int res1 = 0 ;
11842 PyObject *swig_obj[1] ;
11843
11844 if (!args) SWIG_fail;
11845 swig_obj[0] = args;
11846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11847 if (!SWIG_IsOK(res1)) {
11848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11849 }
11850 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 {
11858 resultobj = wxPyMake_wxObject(result, (bool)0);
11859 }
11860 return resultobj;
11861 fail:
11862 return NULL;
11863 }
11864
11865
11866 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11867 PyObject *resultobj = 0;
11868 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11869 wxLog *result = 0 ;
11870 void *argp1 = 0 ;
11871 int res1 = 0 ;
11872 PyObject *swig_obj[1] ;
11873
11874 if (!args) SWIG_fail;
11875 swig_obj[0] = args;
11876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11877 if (!SWIG_IsOK(res1)) {
11878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11879 }
11880 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11888 return resultobj;
11889 fail:
11890 return NULL;
11891 }
11892
11893
11894 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11895 PyObject *resultobj = 0;
11896 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11897 bool result;
11898 void *argp1 = 0 ;
11899 int res1 = 0 ;
11900 PyObject *swig_obj[1] ;
11901
11902 if (!args) SWIG_fail;
11903 swig_obj[0] = args;
11904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11905 if (!SWIG_IsOK(res1)) {
11906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11907 }
11908 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11909 {
11910 PyThreadState* __tstate = wxPyBeginAllowThreads();
11911 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11912 wxPyEndAllowThreads(__tstate);
11913 if (PyErr_Occurred()) SWIG_fail;
11914 }
11915 {
11916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11917 }
11918 return resultobj;
11919 fail:
11920 return NULL;
11921 }
11922
11923
11924 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11925 PyObject *resultobj = 0;
11926 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11927 bool arg2 ;
11928 void *argp1 = 0 ;
11929 int res1 = 0 ;
11930 bool val2 ;
11931 int ecode2 = 0 ;
11932 PyObject * obj0 = 0 ;
11933 PyObject * obj1 = 0 ;
11934 char * kwnames[] = {
11935 (char *) "self",(char *) "bDoPass", NULL
11936 };
11937
11938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11940 if (!SWIG_IsOK(res1)) {
11941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11942 }
11943 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11945 if (!SWIG_IsOK(ecode2)) {
11946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11947 }
11948 arg2 = static_cast< bool >(val2);
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 (arg1)->PassMessages(arg2);
11952 wxPyEndAllowThreads(__tstate);
11953 if (PyErr_Occurred()) SWIG_fail;
11954 }
11955 resultobj = SWIG_Py_Void();
11956 return resultobj;
11957 fail:
11958 return NULL;
11959 }
11960
11961
11962 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11963 PyObject *obj;
11964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11965 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11966 return SWIG_Py_Void();
11967 }
11968
11969 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11970 return SWIG_Python_InitShadowInstance(args);
11971 }
11972
11973 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11974 PyObject *resultobj = 0;
11975 wxLog *arg1 = (wxLog *) 0 ;
11976 wxLogChain *result = 0 ;
11977 void *argp1 = 0 ;
11978 int res1 = 0 ;
11979 PyObject * obj0 = 0 ;
11980 char * kwnames[] = {
11981 (char *) "logger", NULL
11982 };
11983
11984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
11985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11986 if (!SWIG_IsOK(res1)) {
11987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
11988 }
11989 arg1 = reinterpret_cast< wxLog * >(argp1);
11990 {
11991 PyThreadState* __tstate = wxPyBeginAllowThreads();
11992 result = (wxLogChain *)new wxLogChain(arg1);
11993 wxPyEndAllowThreads(__tstate);
11994 if (PyErr_Occurred()) SWIG_fail;
11995 }
11996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj = 0;
12005 wxLogChain *arg1 = (wxLogChain *) 0 ;
12006 wxLog *arg2 = (wxLog *) 0 ;
12007 void *argp1 = 0 ;
12008 int res1 = 0 ;
12009 void *argp2 = 0 ;
12010 int res2 = 0 ;
12011 PyObject * obj0 = 0 ;
12012 PyObject * obj1 = 0 ;
12013 char * kwnames[] = {
12014 (char *) "self",(char *) "logger", NULL
12015 };
12016
12017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12019 if (!SWIG_IsOK(res1)) {
12020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12021 }
12022 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12023 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12024 if (!SWIG_IsOK(res2)) {
12025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12026 }
12027 arg2 = reinterpret_cast< wxLog * >(argp2);
12028 {
12029 PyThreadState* __tstate = wxPyBeginAllowThreads();
12030 (arg1)->SetLog(arg2);
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 resultobj = SWIG_Py_Void();
12035 return resultobj;
12036 fail:
12037 return NULL;
12038 }
12039
12040
12041 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12042 PyObject *resultobj = 0;
12043 wxLogChain *arg1 = (wxLogChain *) 0 ;
12044 bool arg2 ;
12045 void *argp1 = 0 ;
12046 int res1 = 0 ;
12047 bool val2 ;
12048 int ecode2 = 0 ;
12049 PyObject * obj0 = 0 ;
12050 PyObject * obj1 = 0 ;
12051 char * kwnames[] = {
12052 (char *) "self",(char *) "bDoPass", NULL
12053 };
12054
12055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12057 if (!SWIG_IsOK(res1)) {
12058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12059 }
12060 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12061 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12062 if (!SWIG_IsOK(ecode2)) {
12063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12064 }
12065 arg2 = static_cast< bool >(val2);
12066 {
12067 PyThreadState* __tstate = wxPyBeginAllowThreads();
12068 (arg1)->PassMessages(arg2);
12069 wxPyEndAllowThreads(__tstate);
12070 if (PyErr_Occurred()) SWIG_fail;
12071 }
12072 resultobj = SWIG_Py_Void();
12073 return resultobj;
12074 fail:
12075 return NULL;
12076 }
12077
12078
12079 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12080 PyObject *resultobj = 0;
12081 wxLogChain *arg1 = (wxLogChain *) 0 ;
12082 bool result;
12083 void *argp1 = 0 ;
12084 int res1 = 0 ;
12085 PyObject *swig_obj[1] ;
12086
12087 if (!args) SWIG_fail;
12088 swig_obj[0] = args;
12089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12090 if (!SWIG_IsOK(res1)) {
12091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12092 }
12093 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12094 {
12095 PyThreadState* __tstate = wxPyBeginAllowThreads();
12096 result = (bool)(arg1)->IsPassingMessages();
12097 wxPyEndAllowThreads(__tstate);
12098 if (PyErr_Occurred()) SWIG_fail;
12099 }
12100 {
12101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12102 }
12103 return resultobj;
12104 fail:
12105 return NULL;
12106 }
12107
12108
12109 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12110 PyObject *resultobj = 0;
12111 wxLogChain *arg1 = (wxLogChain *) 0 ;
12112 wxLog *result = 0 ;
12113 void *argp1 = 0 ;
12114 int res1 = 0 ;
12115 PyObject *swig_obj[1] ;
12116
12117 if (!args) SWIG_fail;
12118 swig_obj[0] = args;
12119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12120 if (!SWIG_IsOK(res1)) {
12121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12122 }
12123 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12124 {
12125 PyThreadState* __tstate = wxPyBeginAllowThreads();
12126 result = (wxLog *)(arg1)->GetOldLog();
12127 wxPyEndAllowThreads(__tstate);
12128 if (PyErr_Occurred()) SWIG_fail;
12129 }
12130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12131 return resultobj;
12132 fail:
12133 return NULL;
12134 }
12135
12136
12137 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12138 PyObject *obj;
12139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12140 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12141 return SWIG_Py_Void();
12142 }
12143
12144 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 return SWIG_Python_InitShadowInstance(args);
12146 }
12147
12148 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12149 PyObject *resultobj = 0;
12150 wxLogBuffer *result = 0 ;
12151
12152 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (wxLogBuffer *)new wxLogBuffer();
12156 wxPyEndAllowThreads(__tstate);
12157 if (PyErr_Occurred()) SWIG_fail;
12158 }
12159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12160 return resultobj;
12161 fail:
12162 return NULL;
12163 }
12164
12165
12166 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12167 PyObject *resultobj = 0;
12168 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12169 wxString *result = 0 ;
12170 void *argp1 = 0 ;
12171 int res1 = 0 ;
12172 PyObject *swig_obj[1] ;
12173
12174 if (!args) SWIG_fail;
12175 swig_obj[0] = args;
12176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12177 if (!SWIG_IsOK(res1)) {
12178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12179 }
12180 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12181 {
12182 PyThreadState* __tstate = wxPyBeginAllowThreads();
12183 {
12184 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12185 result = (wxString *) &_result_ref;
12186 }
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 {
12191 #if wxUSE_UNICODE
12192 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12193 #else
12194 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12195 #endif
12196 }
12197 return resultobj;
12198 fail:
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12204 PyObject *obj;
12205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12206 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12207 return SWIG_Py_Void();
12208 }
12209
12210 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211 return SWIG_Python_InitShadowInstance(args);
12212 }
12213
12214 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12215 PyObject *resultobj = 0;
12216 unsigned long result;
12217
12218 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 result = (unsigned long)wxSysErrorCode();
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12233 PyObject *resultobj = 0;
12234 unsigned long arg1 = (unsigned long) 0 ;
12235 wxString result;
12236 unsigned long val1 ;
12237 int ecode1 = 0 ;
12238 PyObject * obj0 = 0 ;
12239 char * kwnames[] = {
12240 (char *) "nErrCode", NULL
12241 };
12242
12243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12244 if (obj0) {
12245 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12246 if (!SWIG_IsOK(ecode1)) {
12247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12248 }
12249 arg1 = static_cast< unsigned long >(val1);
12250 }
12251 {
12252 PyThreadState* __tstate = wxPyBeginAllowThreads();
12253 result = wxSysErrorMsg(arg1);
12254 wxPyEndAllowThreads(__tstate);
12255 if (PyErr_Occurred()) SWIG_fail;
12256 }
12257 {
12258 #if wxUSE_UNICODE
12259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12260 #else
12261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12262 #endif
12263 }
12264 return resultobj;
12265 fail:
12266 return NULL;
12267 }
12268
12269
12270 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12271 PyObject *resultobj = 0;
12272 wxString *arg1 = 0 ;
12273 bool temp1 = false ;
12274 PyObject * obj0 = 0 ;
12275 char * kwnames[] = {
12276 (char *) "msg", NULL
12277 };
12278
12279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12280 {
12281 arg1 = wxString_in_helper(obj0);
12282 if (arg1 == NULL) SWIG_fail;
12283 temp1 = true;
12284 }
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 wxPyLogFatalError((wxString const &)*arg1);
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 resultobj = SWIG_Py_Void();
12292 {
12293 if (temp1)
12294 delete arg1;
12295 }
12296 return resultobj;
12297 fail:
12298 {
12299 if (temp1)
12300 delete arg1;
12301 }
12302 return NULL;
12303 }
12304
12305
12306 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12307 PyObject *resultobj = 0;
12308 wxString *arg1 = 0 ;
12309 bool temp1 = false ;
12310 PyObject * obj0 = 0 ;
12311 char * kwnames[] = {
12312 (char *) "msg", NULL
12313 };
12314
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12316 {
12317 arg1 = wxString_in_helper(obj0);
12318 if (arg1 == NULL) SWIG_fail;
12319 temp1 = true;
12320 }
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 wxPyLogError((wxString const &)*arg1);
12324 wxPyEndAllowThreads(__tstate);
12325 if (PyErr_Occurred()) SWIG_fail;
12326 }
12327 resultobj = SWIG_Py_Void();
12328 {
12329 if (temp1)
12330 delete arg1;
12331 }
12332 return resultobj;
12333 fail:
12334 {
12335 if (temp1)
12336 delete arg1;
12337 }
12338 return NULL;
12339 }
12340
12341
12342 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12343 PyObject *resultobj = 0;
12344 wxString *arg1 = 0 ;
12345 bool temp1 = false ;
12346 PyObject * obj0 = 0 ;
12347 char * kwnames[] = {
12348 (char *) "msg", NULL
12349 };
12350
12351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12352 {
12353 arg1 = wxString_in_helper(obj0);
12354 if (arg1 == NULL) SWIG_fail;
12355 temp1 = true;
12356 }
12357 {
12358 PyThreadState* __tstate = wxPyBeginAllowThreads();
12359 wxPyLogWarning((wxString const &)*arg1);
12360 wxPyEndAllowThreads(__tstate);
12361 if (PyErr_Occurred()) SWIG_fail;
12362 }
12363 resultobj = SWIG_Py_Void();
12364 {
12365 if (temp1)
12366 delete arg1;
12367 }
12368 return resultobj;
12369 fail:
12370 {
12371 if (temp1)
12372 delete arg1;
12373 }
12374 return NULL;
12375 }
12376
12377
12378 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12379 PyObject *resultobj = 0;
12380 wxString *arg1 = 0 ;
12381 bool temp1 = false ;
12382 PyObject * obj0 = 0 ;
12383 char * kwnames[] = {
12384 (char *) "msg", NULL
12385 };
12386
12387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12388 {
12389 arg1 = wxString_in_helper(obj0);
12390 if (arg1 == NULL) SWIG_fail;
12391 temp1 = true;
12392 }
12393 {
12394 PyThreadState* __tstate = wxPyBeginAllowThreads();
12395 wxPyLogMessage((wxString const &)*arg1);
12396 wxPyEndAllowThreads(__tstate);
12397 if (PyErr_Occurred()) SWIG_fail;
12398 }
12399 resultobj = SWIG_Py_Void();
12400 {
12401 if (temp1)
12402 delete arg1;
12403 }
12404 return resultobj;
12405 fail:
12406 {
12407 if (temp1)
12408 delete arg1;
12409 }
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxString *arg1 = 0 ;
12417 bool temp1 = false ;
12418 PyObject * obj0 = 0 ;
12419 char * kwnames[] = {
12420 (char *) "msg", NULL
12421 };
12422
12423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12424 {
12425 arg1 = wxString_in_helper(obj0);
12426 if (arg1 == NULL) SWIG_fail;
12427 temp1 = true;
12428 }
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 wxPyLogInfo((wxString const &)*arg1);
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_Py_Void();
12436 {
12437 if (temp1)
12438 delete arg1;
12439 }
12440 return resultobj;
12441 fail:
12442 {
12443 if (temp1)
12444 delete arg1;
12445 }
12446 return NULL;
12447 }
12448
12449
12450 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj = 0;
12452 wxString *arg1 = 0 ;
12453 bool temp1 = false ;
12454 PyObject * obj0 = 0 ;
12455 char * kwnames[] = {
12456 (char *) "msg", NULL
12457 };
12458
12459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12460 {
12461 arg1 = wxString_in_helper(obj0);
12462 if (arg1 == NULL) SWIG_fail;
12463 temp1 = true;
12464 }
12465 {
12466 PyThreadState* __tstate = wxPyBeginAllowThreads();
12467 wxPyLogDebug((wxString const &)*arg1);
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 resultobj = SWIG_Py_Void();
12472 {
12473 if (temp1)
12474 delete arg1;
12475 }
12476 return resultobj;
12477 fail:
12478 {
12479 if (temp1)
12480 delete arg1;
12481 }
12482 return NULL;
12483 }
12484
12485
12486 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12487 PyObject *resultobj = 0;
12488 wxString *arg1 = 0 ;
12489 bool temp1 = false ;
12490 PyObject * obj0 = 0 ;
12491 char * kwnames[] = {
12492 (char *) "msg", NULL
12493 };
12494
12495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12496 {
12497 arg1 = wxString_in_helper(obj0);
12498 if (arg1 == NULL) SWIG_fail;
12499 temp1 = true;
12500 }
12501 {
12502 PyThreadState* __tstate = wxPyBeginAllowThreads();
12503 wxPyLogVerbose((wxString const &)*arg1);
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 resultobj = SWIG_Py_Void();
12508 {
12509 if (temp1)
12510 delete arg1;
12511 }
12512 return resultobj;
12513 fail:
12514 {
12515 if (temp1)
12516 delete arg1;
12517 }
12518 return NULL;
12519 }
12520
12521
12522 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj = 0;
12524 wxString *arg1 = 0 ;
12525 bool temp1 = false ;
12526 PyObject * obj0 = 0 ;
12527 char * kwnames[] = {
12528 (char *) "msg", NULL
12529 };
12530
12531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12532 {
12533 arg1 = wxString_in_helper(obj0);
12534 if (arg1 == NULL) SWIG_fail;
12535 temp1 = true;
12536 }
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 wxPyLogStatus((wxString const &)*arg1);
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 resultobj = SWIG_Py_Void();
12544 {
12545 if (temp1)
12546 delete arg1;
12547 }
12548 return resultobj;
12549 fail:
12550 {
12551 if (temp1)
12552 delete arg1;
12553 }
12554 return NULL;
12555 }
12556
12557
12558 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12559 PyObject *resultobj = 0;
12560 wxFrame *arg1 = (wxFrame *) 0 ;
12561 wxString *arg2 = 0 ;
12562 void *argp1 = 0 ;
12563 int res1 = 0 ;
12564 bool temp2 = false ;
12565 PyObject * obj0 = 0 ;
12566 PyObject * obj1 = 0 ;
12567 char * kwnames[] = {
12568 (char *) "pFrame",(char *) "msg", NULL
12569 };
12570
12571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12573 if (!SWIG_IsOK(res1)) {
12574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12575 }
12576 arg1 = reinterpret_cast< wxFrame * >(argp1);
12577 {
12578 arg2 = wxString_in_helper(obj1);
12579 if (arg2 == NULL) SWIG_fail;
12580 temp2 = true;
12581 }
12582 {
12583 PyThreadState* __tstate = wxPyBeginAllowThreads();
12584 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12585 wxPyEndAllowThreads(__tstate);
12586 if (PyErr_Occurred()) SWIG_fail;
12587 }
12588 resultobj = SWIG_Py_Void();
12589 {
12590 if (temp2)
12591 delete arg2;
12592 }
12593 return resultobj;
12594 fail:
12595 {
12596 if (temp2)
12597 delete arg2;
12598 }
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12604 PyObject *resultobj = 0;
12605 wxString *arg1 = 0 ;
12606 bool temp1 = false ;
12607 PyObject * obj0 = 0 ;
12608 char * kwnames[] = {
12609 (char *) "msg", NULL
12610 };
12611
12612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12613 {
12614 arg1 = wxString_in_helper(obj0);
12615 if (arg1 == NULL) SWIG_fail;
12616 temp1 = true;
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 wxPyLogSysError((wxString const &)*arg1);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 resultobj = SWIG_Py_Void();
12625 {
12626 if (temp1)
12627 delete arg1;
12628 }
12629 return resultobj;
12630 fail:
12631 {
12632 if (temp1)
12633 delete arg1;
12634 }
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj = 0;
12641 unsigned long arg1 ;
12642 wxString *arg2 = 0 ;
12643 unsigned long val1 ;
12644 int ecode1 = 0 ;
12645 bool temp2 = false ;
12646 PyObject * obj0 = 0 ;
12647 PyObject * obj1 = 0 ;
12648 char * kwnames[] = {
12649 (char *) "level",(char *) "msg", NULL
12650 };
12651
12652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12653 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12654 if (!SWIG_IsOK(ecode1)) {
12655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12656 }
12657 arg1 = static_cast< unsigned long >(val1);
12658 {
12659 arg2 = wxString_in_helper(obj1);
12660 if (arg2 == NULL) SWIG_fail;
12661 temp2 = true;
12662 }
12663 {
12664 PyThreadState* __tstate = wxPyBeginAllowThreads();
12665 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12666 wxPyEndAllowThreads(__tstate);
12667 if (PyErr_Occurred()) SWIG_fail;
12668 }
12669 resultobj = SWIG_Py_Void();
12670 {
12671 if (temp2)
12672 delete arg2;
12673 }
12674 return resultobj;
12675 fail:
12676 {
12677 if (temp2)
12678 delete arg2;
12679 }
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12685 PyObject *resultobj = 0;
12686 unsigned long arg1 ;
12687 wxString *arg2 = 0 ;
12688 unsigned long val1 ;
12689 int ecode1 = 0 ;
12690 bool temp2 = false ;
12691
12692 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12693 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12694 if (!SWIG_IsOK(ecode1)) {
12695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12696 }
12697 arg1 = static_cast< unsigned long >(val1);
12698 {
12699 arg2 = wxString_in_helper(swig_obj[1]);
12700 if (arg2 == NULL) SWIG_fail;
12701 temp2 = true;
12702 }
12703 {
12704 PyThreadState* __tstate = wxPyBeginAllowThreads();
12705 wxPyLogTrace(arg1,(wxString const &)*arg2);
12706 wxPyEndAllowThreads(__tstate);
12707 if (PyErr_Occurred()) SWIG_fail;
12708 }
12709 resultobj = SWIG_Py_Void();
12710 {
12711 if (temp2)
12712 delete arg2;
12713 }
12714 return resultobj;
12715 fail:
12716 {
12717 if (temp2)
12718 delete arg2;
12719 }
12720 return NULL;
12721 }
12722
12723
12724 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12725 PyObject *resultobj = 0;
12726 wxString *arg1 = 0 ;
12727 wxString *arg2 = 0 ;
12728 bool temp1 = false ;
12729 bool temp2 = false ;
12730
12731 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12732 {
12733 arg1 = wxString_in_helper(swig_obj[0]);
12734 if (arg1 == NULL) SWIG_fail;
12735 temp1 = true;
12736 }
12737 {
12738 arg2 = wxString_in_helper(swig_obj[1]);
12739 if (arg2 == NULL) SWIG_fail;
12740 temp2 = true;
12741 }
12742 {
12743 PyThreadState* __tstate = wxPyBeginAllowThreads();
12744 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12745 wxPyEndAllowThreads(__tstate);
12746 if (PyErr_Occurred()) SWIG_fail;
12747 }
12748 resultobj = SWIG_Py_Void();
12749 {
12750 if (temp1)
12751 delete arg1;
12752 }
12753 {
12754 if (temp2)
12755 delete arg2;
12756 }
12757 return resultobj;
12758 fail:
12759 {
12760 if (temp1)
12761 delete arg1;
12762 }
12763 {
12764 if (temp2)
12765 delete arg2;
12766 }
12767 return NULL;
12768 }
12769
12770
12771 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12772 int argc;
12773 PyObject *argv[3];
12774
12775 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12776 --argc;
12777 if (argc == 2) {
12778 int _v = 0;
12779 {
12780 {
12781 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12782 }
12783 }
12784 if (!_v) goto check_1;
12785 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12786 }
12787 check_1:
12788
12789 if (argc == 2) {
12790 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12791 }
12792
12793 fail:
12794 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12795 return NULL;
12796 }
12797
12798
12799 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12800 PyObject *resultobj = 0;
12801 wxString *arg1 = 0 ;
12802 wxString *arg2 = 0 ;
12803 bool temp1 = false ;
12804 bool temp2 = false ;
12805 PyObject * obj0 = 0 ;
12806 PyObject * obj1 = 0 ;
12807 char * kwnames[] = {
12808 (char *) "title",(char *) "text", NULL
12809 };
12810
12811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12812 {
12813 arg1 = wxString_in_helper(obj0);
12814 if (arg1 == NULL) SWIG_fail;
12815 temp1 = true;
12816 }
12817 {
12818 arg2 = wxString_in_helper(obj1);
12819 if (arg2 == NULL) SWIG_fail;
12820 temp2 = true;
12821 }
12822 {
12823 PyThreadState* __tstate = wxPyBeginAllowThreads();
12824 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12825 wxPyEndAllowThreads(__tstate);
12826 if (PyErr_Occurred()) SWIG_fail;
12827 }
12828 resultobj = SWIG_Py_Void();
12829 {
12830 if (temp1)
12831 delete arg1;
12832 }
12833 {
12834 if (temp2)
12835 delete arg2;
12836 }
12837 return resultobj;
12838 fail:
12839 {
12840 if (temp1)
12841 delete arg1;
12842 }
12843 {
12844 if (temp2)
12845 delete arg2;
12846 }
12847 return NULL;
12848 }
12849
12850
12851 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12852 PyObject *resultobj = 0;
12853 wxLogNull *result = 0 ;
12854
12855 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12856 {
12857 PyThreadState* __tstate = wxPyBeginAllowThreads();
12858 result = (wxLogNull *)new wxLogNull();
12859 wxPyEndAllowThreads(__tstate);
12860 if (PyErr_Occurred()) SWIG_fail;
12861 }
12862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12870 PyObject *resultobj = 0;
12871 wxLogNull *arg1 = (wxLogNull *) 0 ;
12872 void *argp1 = 0 ;
12873 int res1 = 0 ;
12874 PyObject *swig_obj[1] ;
12875
12876 if (!args) SWIG_fail;
12877 swig_obj[0] = args;
12878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12879 if (!SWIG_IsOK(res1)) {
12880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12881 }
12882 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 delete arg1;
12886
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 resultobj = SWIG_Py_Void();
12891 return resultobj;
12892 fail:
12893 return NULL;
12894 }
12895
12896
12897 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12898 PyObject *obj;
12899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12900 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12901 return SWIG_Py_Void();
12902 }
12903
12904 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12905 return SWIG_Python_InitShadowInstance(args);
12906 }
12907
12908 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *resultobj = 0;
12910 wxPyLog *result = 0 ;
12911
12912 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12913 {
12914 PyThreadState* __tstate = wxPyBeginAllowThreads();
12915 result = (wxPyLog *)new wxPyLog();
12916 wxPyEndAllowThreads(__tstate);
12917 if (PyErr_Occurred()) SWIG_fail;
12918 }
12919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12927 PyObject *resultobj = 0;
12928 wxPyLog *arg1 = (wxPyLog *) 0 ;
12929 PyObject *arg2 = (PyObject *) 0 ;
12930 PyObject *arg3 = (PyObject *) 0 ;
12931 void *argp1 = 0 ;
12932 int res1 = 0 ;
12933 PyObject * obj0 = 0 ;
12934 PyObject * obj1 = 0 ;
12935 PyObject * obj2 = 0 ;
12936 char * kwnames[] = {
12937 (char *) "self",(char *) "self",(char *) "_class", NULL
12938 };
12939
12940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12942 if (!SWIG_IsOK(res1)) {
12943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12944 }
12945 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12946 arg2 = obj1;
12947 arg3 = obj2;
12948 {
12949 PyThreadState* __tstate = wxPyBeginAllowThreads();
12950 (arg1)->_setCallbackInfo(arg2,arg3);
12951 wxPyEndAllowThreads(__tstate);
12952 if (PyErr_Occurred()) SWIG_fail;
12953 }
12954 resultobj = SWIG_Py_Void();
12955 return resultobj;
12956 fail:
12957 return NULL;
12958 }
12959
12960
12961 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12962 PyObject *obj;
12963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12964 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12965 return SWIG_Py_Void();
12966 }
12967
12968 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12969 return SWIG_Python_InitShadowInstance(args);
12970 }
12971
12972 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12973 PyObject *resultobj = 0;
12974 int arg1 ;
12975 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12976 int arg3 = (int) wxKILL_NOCHILDREN ;
12977 wxKillError result;
12978 int val1 ;
12979 int ecode1 = 0 ;
12980 int val2 ;
12981 int ecode2 = 0 ;
12982 int val3 ;
12983 int ecode3 = 0 ;
12984 PyObject * obj0 = 0 ;
12985 PyObject * obj1 = 0 ;
12986 PyObject * obj2 = 0 ;
12987 char * kwnames[] = {
12988 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12989 };
12990
12991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12992 ecode1 = SWIG_AsVal_int(obj0, &val1);
12993 if (!SWIG_IsOK(ecode1)) {
12994 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
12995 }
12996 arg1 = static_cast< int >(val1);
12997 if (obj1) {
12998 ecode2 = SWIG_AsVal_int(obj1, &val2);
12999 if (!SWIG_IsOK(ecode2)) {
13000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13001 }
13002 arg2 = static_cast< wxSignal >(val2);
13003 }
13004 if (obj2) {
13005 ecode3 = SWIG_AsVal_int(obj2, &val3);
13006 if (!SWIG_IsOK(ecode3)) {
13007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13008 }
13009 arg3 = static_cast< int >(val3);
13010 }
13011 {
13012 PyThreadState* __tstate = wxPyBeginAllowThreads();
13013 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13014 wxPyEndAllowThreads(__tstate);
13015 if (PyErr_Occurred()) SWIG_fail;
13016 }
13017 resultobj = SWIG_From_int(static_cast< int >(result));
13018 return resultobj;
13019 fail:
13020 return NULL;
13021 }
13022
13023
13024 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13025 PyObject *resultobj = 0;
13026 int arg1 ;
13027 bool result;
13028 int val1 ;
13029 int ecode1 = 0 ;
13030 PyObject * obj0 = 0 ;
13031 char * kwnames[] = {
13032 (char *) "pid", NULL
13033 };
13034
13035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13036 ecode1 = SWIG_AsVal_int(obj0, &val1);
13037 if (!SWIG_IsOK(ecode1)) {
13038 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13039 }
13040 arg1 = static_cast< int >(val1);
13041 {
13042 PyThreadState* __tstate = wxPyBeginAllowThreads();
13043 result = (bool)wxPyProcess::Exists(arg1);
13044 wxPyEndAllowThreads(__tstate);
13045 if (PyErr_Occurred()) SWIG_fail;
13046 }
13047 {
13048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13049 }
13050 return resultobj;
13051 fail:
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13057 PyObject *resultobj = 0;
13058 wxString *arg1 = 0 ;
13059 int arg2 = (int) wxEXEC_ASYNC ;
13060 wxPyProcess *result = 0 ;
13061 bool temp1 = false ;
13062 int val2 ;
13063 int ecode2 = 0 ;
13064 PyObject * obj0 = 0 ;
13065 PyObject * obj1 = 0 ;
13066 char * kwnames[] = {
13067 (char *) "cmd",(char *) "flags", NULL
13068 };
13069
13070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13071 {
13072 arg1 = wxString_in_helper(obj0);
13073 if (arg1 == NULL) SWIG_fail;
13074 temp1 = true;
13075 }
13076 if (obj1) {
13077 ecode2 = SWIG_AsVal_int(obj1, &val2);
13078 if (!SWIG_IsOK(ecode2)) {
13079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13080 }
13081 arg2 = static_cast< int >(val2);
13082 }
13083 {
13084 PyThreadState* __tstate = wxPyBeginAllowThreads();
13085 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13086 wxPyEndAllowThreads(__tstate);
13087 if (PyErr_Occurred()) SWIG_fail;
13088 }
13089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13090 {
13091 if (temp1)
13092 delete arg1;
13093 }
13094 return resultobj;
13095 fail:
13096 {
13097 if (temp1)
13098 delete arg1;
13099 }
13100 return NULL;
13101 }
13102
13103
13104 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13105 PyObject *resultobj = 0;
13106 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13107 int arg2 = (int) -1 ;
13108 wxPyProcess *result = 0 ;
13109 void *argp1 = 0 ;
13110 int res1 = 0 ;
13111 int val2 ;
13112 int ecode2 = 0 ;
13113 PyObject * obj0 = 0 ;
13114 PyObject * obj1 = 0 ;
13115 char * kwnames[] = {
13116 (char *) "parent",(char *) "id", NULL
13117 };
13118
13119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13120 if (obj0) {
13121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13122 if (!SWIG_IsOK(res1)) {
13123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13124 }
13125 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13126 }
13127 if (obj1) {
13128 ecode2 = SWIG_AsVal_int(obj1, &val2);
13129 if (!SWIG_IsOK(ecode2)) {
13130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13131 }
13132 arg2 = static_cast< int >(val2);
13133 }
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13137 wxPyEndAllowThreads(__tstate);
13138 if (PyErr_Occurred()) SWIG_fail;
13139 }
13140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13141 return resultobj;
13142 fail:
13143 return NULL;
13144 }
13145
13146
13147 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13148 PyObject *resultobj = 0;
13149 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13150 PyObject *arg2 = (PyObject *) 0 ;
13151 PyObject *arg3 = (PyObject *) 0 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 PyObject * obj0 = 0 ;
13155 PyObject * obj1 = 0 ;
13156 PyObject * obj2 = 0 ;
13157 char * kwnames[] = {
13158 (char *) "self",(char *) "self",(char *) "_class", NULL
13159 };
13160
13161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13163 if (!SWIG_IsOK(res1)) {
13164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13165 }
13166 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13167 arg2 = obj1;
13168 arg3 = obj2;
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 (arg1)->_setCallbackInfo(arg2,arg3);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 resultobj = SWIG_Py_Void();
13176 return resultobj;
13177 fail:
13178 return NULL;
13179 }
13180
13181
13182 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj = 0;
13184 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13185 int arg2 ;
13186 int arg3 ;
13187 void *argp1 = 0 ;
13188 int res1 = 0 ;
13189 int val2 ;
13190 int ecode2 = 0 ;
13191 int val3 ;
13192 int ecode3 = 0 ;
13193 PyObject * obj0 = 0 ;
13194 PyObject * obj1 = 0 ;
13195 PyObject * obj2 = 0 ;
13196 char * kwnames[] = {
13197 (char *) "self",(char *) "pid",(char *) "status", NULL
13198 };
13199
13200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13202 if (!SWIG_IsOK(res1)) {
13203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13204 }
13205 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13206 ecode2 = SWIG_AsVal_int(obj1, &val2);
13207 if (!SWIG_IsOK(ecode2)) {
13208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13209 }
13210 arg2 = static_cast< int >(val2);
13211 ecode3 = SWIG_AsVal_int(obj2, &val3);
13212 if (!SWIG_IsOK(ecode3)) {
13213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13214 }
13215 arg3 = static_cast< int >(val3);
13216 {
13217 PyThreadState* __tstate = wxPyBeginAllowThreads();
13218 (arg1)->OnTerminate(arg2,arg3);
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 resultobj = SWIG_Py_Void();
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13230 PyObject *resultobj = 0;
13231 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13232 void *argp1 = 0 ;
13233 int res1 = 0 ;
13234 PyObject *swig_obj[1] ;
13235
13236 if (!args) SWIG_fail;
13237 swig_obj[0] = args;
13238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13239 if (!SWIG_IsOK(res1)) {
13240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13241 }
13242 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 (arg1)->Redirect();
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 resultobj = SWIG_Py_Void();
13250 return resultobj;
13251 fail:
13252 return NULL;
13253 }
13254
13255
13256 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13257 PyObject *resultobj = 0;
13258 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13259 bool result;
13260 void *argp1 = 0 ;
13261 int res1 = 0 ;
13262 PyObject *swig_obj[1] ;
13263
13264 if (!args) SWIG_fail;
13265 swig_obj[0] = args;
13266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13267 if (!SWIG_IsOK(res1)) {
13268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13269 }
13270 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13271 {
13272 PyThreadState* __tstate = wxPyBeginAllowThreads();
13273 result = (bool)(arg1)->IsRedirected();
13274 wxPyEndAllowThreads(__tstate);
13275 if (PyErr_Occurred()) SWIG_fail;
13276 }
13277 {
13278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13279 }
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13287 PyObject *resultobj = 0;
13288 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13289 void *argp1 = 0 ;
13290 int res1 = 0 ;
13291 PyObject *swig_obj[1] ;
13292
13293 if (!args) SWIG_fail;
13294 swig_obj[0] = args;
13295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13296 if (!SWIG_IsOK(res1)) {
13297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13298 }
13299 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13300 {
13301 PyThreadState* __tstate = wxPyBeginAllowThreads();
13302 (arg1)->Detach();
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 resultobj = SWIG_Py_Void();
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13314 PyObject *resultobj = 0;
13315 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13316 wxInputStream *result = 0 ;
13317 void *argp1 = 0 ;
13318 int res1 = 0 ;
13319 PyObject *swig_obj[1] ;
13320
13321 if (!args) SWIG_fail;
13322 swig_obj[0] = args;
13323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13326 }
13327 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 result = (wxInputStream *)(arg1)->GetInputStream();
13331 wxPyEndAllowThreads(__tstate);
13332 if (PyErr_Occurred()) SWIG_fail;
13333 }
13334 {
13335 wxPyInputStream * _ptr = NULL;
13336
13337 if (result) {
13338 _ptr = new wxPyInputStream(result);
13339 }
13340 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13341 }
13342 return resultobj;
13343 fail:
13344 return NULL;
13345 }
13346
13347
13348 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13349 PyObject *resultobj = 0;
13350 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13351 wxInputStream *result = 0 ;
13352 void *argp1 = 0 ;
13353 int res1 = 0 ;
13354 PyObject *swig_obj[1] ;
13355
13356 if (!args) SWIG_fail;
13357 swig_obj[0] = args;
13358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13359 if (!SWIG_IsOK(res1)) {
13360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13361 }
13362 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13363 {
13364 PyThreadState* __tstate = wxPyBeginAllowThreads();
13365 result = (wxInputStream *)(arg1)->GetErrorStream();
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 {
13370 wxPyInputStream * _ptr = NULL;
13371
13372 if (result) {
13373 _ptr = new wxPyInputStream(result);
13374 }
13375 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13376 }
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13384 PyObject *resultobj = 0;
13385 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13386 wxOutputStream *result = 0 ;
13387 void *argp1 = 0 ;
13388 int res1 = 0 ;
13389 PyObject *swig_obj[1] ;
13390
13391 if (!args) SWIG_fail;
13392 swig_obj[0] = args;
13393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13394 if (!SWIG_IsOK(res1)) {
13395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13396 }
13397 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13398 {
13399 PyThreadState* __tstate = wxPyBeginAllowThreads();
13400 result = (wxOutputStream *)(arg1)->GetOutputStream();
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13405 return resultobj;
13406 fail:
13407 return NULL;
13408 }
13409
13410
13411 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13412 PyObject *resultobj = 0;
13413 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13414 void *argp1 = 0 ;
13415 int res1 = 0 ;
13416 PyObject *swig_obj[1] ;
13417
13418 if (!args) SWIG_fail;
13419 swig_obj[0] = args;
13420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13421 if (!SWIG_IsOK(res1)) {
13422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13423 }
13424 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 (arg1)->CloseOutput();
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 resultobj = SWIG_Py_Void();
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *resultobj = 0;
13440 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13441 bool result;
13442 void *argp1 = 0 ;
13443 int res1 = 0 ;
13444 PyObject *swig_obj[1] ;
13445
13446 if (!args) SWIG_fail;
13447 swig_obj[0] = args;
13448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13449 if (!SWIG_IsOK(res1)) {
13450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13451 }
13452 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 {
13460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13461 }
13462 return resultobj;
13463 fail:
13464 return NULL;
13465 }
13466
13467
13468 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13469 PyObject *resultobj = 0;
13470 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13471 bool result;
13472 void *argp1 = 0 ;
13473 int res1 = 0 ;
13474 PyObject *swig_obj[1] ;
13475
13476 if (!args) SWIG_fail;
13477 swig_obj[0] = args;
13478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13479 if (!SWIG_IsOK(res1)) {
13480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13481 }
13482 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13483 {
13484 PyThreadState* __tstate = wxPyBeginAllowThreads();
13485 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13486 wxPyEndAllowThreads(__tstate);
13487 if (PyErr_Occurred()) SWIG_fail;
13488 }
13489 {
13490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13491 }
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13499 PyObject *resultobj = 0;
13500 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13501 bool result;
13502 void *argp1 = 0 ;
13503 int res1 = 0 ;
13504 PyObject *swig_obj[1] ;
13505
13506 if (!args) SWIG_fail;
13507 swig_obj[0] = args;
13508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13509 if (!SWIG_IsOK(res1)) {
13510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13511 }
13512 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13513 {
13514 PyThreadState* __tstate = wxPyBeginAllowThreads();
13515 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 {
13520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13521 }
13522 return resultobj;
13523 fail:
13524 return NULL;
13525 }
13526
13527
13528 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13529 PyObject *obj;
13530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13531 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13532 return SWIG_Py_Void();
13533 }
13534
13535 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13536 return SWIG_Python_InitShadowInstance(args);
13537 }
13538
13539 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13540 PyObject *resultobj = 0;
13541 int arg1 = (int) 0 ;
13542 int arg2 = (int) 0 ;
13543 int arg3 = (int) 0 ;
13544 wxProcessEvent *result = 0 ;
13545 int val1 ;
13546 int ecode1 = 0 ;
13547 int val2 ;
13548 int ecode2 = 0 ;
13549 int val3 ;
13550 int ecode3 = 0 ;
13551 PyObject * obj0 = 0 ;
13552 PyObject * obj1 = 0 ;
13553 PyObject * obj2 = 0 ;
13554 char * kwnames[] = {
13555 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13556 };
13557
13558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13559 if (obj0) {
13560 ecode1 = SWIG_AsVal_int(obj0, &val1);
13561 if (!SWIG_IsOK(ecode1)) {
13562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13563 }
13564 arg1 = static_cast< int >(val1);
13565 }
13566 if (obj1) {
13567 ecode2 = SWIG_AsVal_int(obj1, &val2);
13568 if (!SWIG_IsOK(ecode2)) {
13569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13570 }
13571 arg2 = static_cast< int >(val2);
13572 }
13573 if (obj2) {
13574 ecode3 = SWIG_AsVal_int(obj2, &val3);
13575 if (!SWIG_IsOK(ecode3)) {
13576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13577 }
13578 arg3 = static_cast< int >(val3);
13579 }
13580 {
13581 PyThreadState* __tstate = wxPyBeginAllowThreads();
13582 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13583 wxPyEndAllowThreads(__tstate);
13584 if (PyErr_Occurred()) SWIG_fail;
13585 }
13586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13587 return resultobj;
13588 fail:
13589 return NULL;
13590 }
13591
13592
13593 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13594 PyObject *resultobj = 0;
13595 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13596 int result;
13597 void *argp1 = 0 ;
13598 int res1 = 0 ;
13599 PyObject *swig_obj[1] ;
13600
13601 if (!args) SWIG_fail;
13602 swig_obj[0] = args;
13603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13604 if (!SWIG_IsOK(res1)) {
13605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13606 }
13607 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = (int)(arg1)->GetPid();
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_From_int(static_cast< int >(result));
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13622 PyObject *resultobj = 0;
13623 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13624 int result;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 PyObject *swig_obj[1] ;
13628
13629 if (!args) SWIG_fail;
13630 swig_obj[0] = args;
13631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13632 if (!SWIG_IsOK(res1)) {
13633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13634 }
13635 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 result = (int)(arg1)->GetExitCode();
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 resultobj = SWIG_From_int(static_cast< int >(result));
13643 return resultobj;
13644 fail:
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13650 PyObject *resultobj = 0;
13651 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13652 int arg2 ;
13653 void *argp1 = 0 ;
13654 int res1 = 0 ;
13655 int val2 ;
13656 int ecode2 = 0 ;
13657 PyObject *swig_obj[2] ;
13658
13659 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13661 if (!SWIG_IsOK(res1)) {
13662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13663 }
13664 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13665 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13666 if (!SWIG_IsOK(ecode2)) {
13667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13668 }
13669 arg2 = static_cast< int >(val2);
13670 if (arg1) (arg1)->m_pid = arg2;
13671
13672 resultobj = SWIG_Py_Void();
13673 return resultobj;
13674 fail:
13675 return NULL;
13676 }
13677
13678
13679 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13680 PyObject *resultobj = 0;
13681 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13682 int result;
13683 void *argp1 = 0 ;
13684 int res1 = 0 ;
13685 PyObject *swig_obj[1] ;
13686
13687 if (!args) SWIG_fail;
13688 swig_obj[0] = args;
13689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13690 if (!SWIG_IsOK(res1)) {
13691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13692 }
13693 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13694 result = (int) ((arg1)->m_pid);
13695 resultobj = SWIG_From_int(static_cast< int >(result));
13696 return resultobj;
13697 fail:
13698 return NULL;
13699 }
13700
13701
13702 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13703 PyObject *resultobj = 0;
13704 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13705 int arg2 ;
13706 void *argp1 = 0 ;
13707 int res1 = 0 ;
13708 int val2 ;
13709 int ecode2 = 0 ;
13710 PyObject *swig_obj[2] ;
13711
13712 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13714 if (!SWIG_IsOK(res1)) {
13715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13716 }
13717 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13718 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13719 if (!SWIG_IsOK(ecode2)) {
13720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13721 }
13722 arg2 = static_cast< int >(val2);
13723 if (arg1) (arg1)->m_exitcode = arg2;
13724
13725 resultobj = SWIG_Py_Void();
13726 return resultobj;
13727 fail:
13728 return NULL;
13729 }
13730
13731
13732 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13733 PyObject *resultobj = 0;
13734 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13735 int result;
13736 void *argp1 = 0 ;
13737 int res1 = 0 ;
13738 PyObject *swig_obj[1] ;
13739
13740 if (!args) SWIG_fail;
13741 swig_obj[0] = args;
13742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13743 if (!SWIG_IsOK(res1)) {
13744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13745 }
13746 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13747 result = (int) ((arg1)->m_exitcode);
13748 resultobj = SWIG_From_int(static_cast< int >(result));
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13756 PyObject *obj;
13757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13758 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13759 return SWIG_Py_Void();
13760 }
13761
13762 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13763 return SWIG_Python_InitShadowInstance(args);
13764 }
13765
13766 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13767 PyObject *resultobj = 0;
13768 wxString *arg1 = 0 ;
13769 int arg2 = (int) wxEXEC_ASYNC ;
13770 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13771 long result;
13772 bool temp1 = false ;
13773 int val2 ;
13774 int ecode2 = 0 ;
13775 void *argp3 = 0 ;
13776 int res3 = 0 ;
13777 PyObject * obj0 = 0 ;
13778 PyObject * obj1 = 0 ;
13779 PyObject * obj2 = 0 ;
13780 char * kwnames[] = {
13781 (char *) "command",(char *) "flags",(char *) "process", NULL
13782 };
13783
13784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13785 {
13786 arg1 = wxString_in_helper(obj0);
13787 if (arg1 == NULL) SWIG_fail;
13788 temp1 = true;
13789 }
13790 if (obj1) {
13791 ecode2 = SWIG_AsVal_int(obj1, &val2);
13792 if (!SWIG_IsOK(ecode2)) {
13793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13794 }
13795 arg2 = static_cast< int >(val2);
13796 }
13797 if (obj2) {
13798 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13799 if (!SWIG_IsOK(res3)) {
13800 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13801 }
13802 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13803 }
13804 {
13805 if (!wxPyCheckForApp()) SWIG_fail;
13806 PyThreadState* __tstate = wxPyBeginAllowThreads();
13807 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13808 wxPyEndAllowThreads(__tstate);
13809 if (PyErr_Occurred()) SWIG_fail;
13810 }
13811 resultobj = SWIG_From_long(static_cast< long >(result));
13812 {
13813 if (temp1)
13814 delete arg1;
13815 }
13816 return resultobj;
13817 fail:
13818 {
13819 if (temp1)
13820 delete arg1;
13821 }
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 long arg1 ;
13829 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13830 wxKillError *arg3 = (wxKillError *) 0 ;
13831 int arg4 = (int) wxKILL_NOCHILDREN ;
13832 int result;
13833 long val1 ;
13834 int ecode1 = 0 ;
13835 int val2 ;
13836 int ecode2 = 0 ;
13837 wxKillError temp3 ;
13838 int val4 ;
13839 int ecode4 = 0 ;
13840 PyObject * obj0 = 0 ;
13841 PyObject * obj1 = 0 ;
13842 PyObject * obj2 = 0 ;
13843 char * kwnames[] = {
13844 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13845 };
13846
13847 {
13848 arg3 = &temp3;
13849 }
13850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13851 ecode1 = SWIG_AsVal_long(obj0, &val1);
13852 if (!SWIG_IsOK(ecode1)) {
13853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13854 }
13855 arg1 = static_cast< long >(val1);
13856 if (obj1) {
13857 ecode2 = SWIG_AsVal_int(obj1, &val2);
13858 if (!SWIG_IsOK(ecode2)) {
13859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13860 }
13861 arg2 = static_cast< wxSignal >(val2);
13862 }
13863 if (obj2) {
13864 ecode4 = SWIG_AsVal_int(obj2, &val4);
13865 if (!SWIG_IsOK(ecode4)) {
13866 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13867 }
13868 arg4 = static_cast< int >(val4);
13869 }
13870 {
13871 PyThreadState* __tstate = wxPyBeginAllowThreads();
13872 result = (int)wxKill(arg1,arg2,arg3,arg4);
13873 wxPyEndAllowThreads(__tstate);
13874 if (PyErr_Occurred()) SWIG_fail;
13875 }
13876 resultobj = SWIG_From_int(static_cast< int >(result));
13877 {
13878 PyObject* o;
13879 o = PyInt_FromLong((long) (*arg3));
13880
13881
13882
13883 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13884
13885 }
13886 return resultobj;
13887 fail:
13888 return NULL;
13889 }
13890
13891
13892 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj = 0;
13894 int arg1 = (int) wxJOYSTICK1 ;
13895 wxJoystick *result = 0 ;
13896 int val1 ;
13897 int ecode1 = 0 ;
13898 PyObject * obj0 = 0 ;
13899 char * kwnames[] = {
13900 (char *) "joystick", NULL
13901 };
13902
13903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13904 if (obj0) {
13905 ecode1 = SWIG_AsVal_int(obj0, &val1);
13906 if (!SWIG_IsOK(ecode1)) {
13907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13908 }
13909 arg1 = static_cast< int >(val1);
13910 }
13911 {
13912 if (!wxPyCheckForApp()) SWIG_fail;
13913 PyThreadState* __tstate = wxPyBeginAllowThreads();
13914 result = (wxJoystick *)new wxJoystick(arg1);
13915 wxPyEndAllowThreads(__tstate);
13916 if (PyErr_Occurred()) SWIG_fail;
13917 }
13918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13919 return resultobj;
13920 fail:
13921 return NULL;
13922 }
13923
13924
13925 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13926 PyObject *resultobj = 0;
13927 wxJoystick *arg1 = (wxJoystick *) 0 ;
13928 void *argp1 = 0 ;
13929 int res1 = 0 ;
13930 PyObject *swig_obj[1] ;
13931
13932 if (!args) SWIG_fail;
13933 swig_obj[0] = args;
13934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13935 if (!SWIG_IsOK(res1)) {
13936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13937 }
13938 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13939 {
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 delete arg1;
13942
13943 wxPyEndAllowThreads(__tstate);
13944 if (PyErr_Occurred()) SWIG_fail;
13945 }
13946 resultobj = SWIG_Py_Void();
13947 return resultobj;
13948 fail:
13949 return NULL;
13950 }
13951
13952
13953 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13954 PyObject *resultobj = 0;
13955 wxJoystick *arg1 = (wxJoystick *) 0 ;
13956 wxPoint result;
13957 void *argp1 = 0 ;
13958 int res1 = 0 ;
13959 PyObject *swig_obj[1] ;
13960
13961 if (!args) SWIG_fail;
13962 swig_obj[0] = args;
13963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13964 if (!SWIG_IsOK(res1)) {
13965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13966 }
13967 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13968 {
13969 PyThreadState* __tstate = wxPyBeginAllowThreads();
13970 result = (arg1)->GetPosition();
13971 wxPyEndAllowThreads(__tstate);
13972 if (PyErr_Occurred()) SWIG_fail;
13973 }
13974 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13975 return resultobj;
13976 fail:
13977 return NULL;
13978 }
13979
13980
13981 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13982 PyObject *resultobj = 0;
13983 wxJoystick *arg1 = (wxJoystick *) 0 ;
13984 int result;
13985 void *argp1 = 0 ;
13986 int res1 = 0 ;
13987 PyObject *swig_obj[1] ;
13988
13989 if (!args) SWIG_fail;
13990 swig_obj[0] = args;
13991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13992 if (!SWIG_IsOK(res1)) {
13993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13994 }
13995 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13996 {
13997 PyThreadState* __tstate = wxPyBeginAllowThreads();
13998 result = (int)(arg1)->GetZPosition();
13999 wxPyEndAllowThreads(__tstate);
14000 if (PyErr_Occurred()) SWIG_fail;
14001 }
14002 resultobj = SWIG_From_int(static_cast< int >(result));
14003 return resultobj;
14004 fail:
14005 return NULL;
14006 }
14007
14008
14009 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14010 PyObject *resultobj = 0;
14011 wxJoystick *arg1 = (wxJoystick *) 0 ;
14012 int result;
14013 void *argp1 = 0 ;
14014 int res1 = 0 ;
14015 PyObject *swig_obj[1] ;
14016
14017 if (!args) SWIG_fail;
14018 swig_obj[0] = args;
14019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14020 if (!SWIG_IsOK(res1)) {
14021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14022 }
14023 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14024 {
14025 PyThreadState* __tstate = wxPyBeginAllowThreads();
14026 result = (int)(arg1)->GetButtonState();
14027 wxPyEndAllowThreads(__tstate);
14028 if (PyErr_Occurred()) SWIG_fail;
14029 }
14030 resultobj = SWIG_From_int(static_cast< int >(result));
14031 return resultobj;
14032 fail:
14033 return NULL;
14034 }
14035
14036
14037 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14038 PyObject *resultobj = 0;
14039 wxJoystick *arg1 = (wxJoystick *) 0 ;
14040 int result;
14041 void *argp1 = 0 ;
14042 int res1 = 0 ;
14043 PyObject *swig_obj[1] ;
14044
14045 if (!args) SWIG_fail;
14046 swig_obj[0] = args;
14047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14048 if (!SWIG_IsOK(res1)) {
14049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14050 }
14051 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14052 {
14053 PyThreadState* __tstate = wxPyBeginAllowThreads();
14054 result = (int)(arg1)->GetPOVPosition();
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 resultobj = SWIG_From_int(static_cast< int >(result));
14059 return resultobj;
14060 fail:
14061 return NULL;
14062 }
14063
14064
14065 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14066 PyObject *resultobj = 0;
14067 wxJoystick *arg1 = (wxJoystick *) 0 ;
14068 int result;
14069 void *argp1 = 0 ;
14070 int res1 = 0 ;
14071 PyObject *swig_obj[1] ;
14072
14073 if (!args) SWIG_fail;
14074 swig_obj[0] = args;
14075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14076 if (!SWIG_IsOK(res1)) {
14077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14078 }
14079 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14080 {
14081 PyThreadState* __tstate = wxPyBeginAllowThreads();
14082 result = (int)(arg1)->GetPOVCTSPosition();
14083 wxPyEndAllowThreads(__tstate);
14084 if (PyErr_Occurred()) SWIG_fail;
14085 }
14086 resultobj = SWIG_From_int(static_cast< int >(result));
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14094 PyObject *resultobj = 0;
14095 wxJoystick *arg1 = (wxJoystick *) 0 ;
14096 int result;
14097 void *argp1 = 0 ;
14098 int res1 = 0 ;
14099 PyObject *swig_obj[1] ;
14100
14101 if (!args) SWIG_fail;
14102 swig_obj[0] = args;
14103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14104 if (!SWIG_IsOK(res1)) {
14105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14106 }
14107 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14108 {
14109 PyThreadState* __tstate = wxPyBeginAllowThreads();
14110 result = (int)(arg1)->GetRudderPosition();
14111 wxPyEndAllowThreads(__tstate);
14112 if (PyErr_Occurred()) SWIG_fail;
14113 }
14114 resultobj = SWIG_From_int(static_cast< int >(result));
14115 return resultobj;
14116 fail:
14117 return NULL;
14118 }
14119
14120
14121 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14122 PyObject *resultobj = 0;
14123 wxJoystick *arg1 = (wxJoystick *) 0 ;
14124 int result;
14125 void *argp1 = 0 ;
14126 int res1 = 0 ;
14127 PyObject *swig_obj[1] ;
14128
14129 if (!args) SWIG_fail;
14130 swig_obj[0] = args;
14131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14132 if (!SWIG_IsOK(res1)) {
14133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14134 }
14135 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (int)(arg1)->GetUPosition();
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 resultobj = SWIG_From_int(static_cast< int >(result));
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14150 PyObject *resultobj = 0;
14151 wxJoystick *arg1 = (wxJoystick *) 0 ;
14152 int result;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 PyObject *swig_obj[1] ;
14156
14157 if (!args) SWIG_fail;
14158 swig_obj[0] = args;
14159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14160 if (!SWIG_IsOK(res1)) {
14161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14162 }
14163 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 result = (int)(arg1)->GetVPosition();
14167 wxPyEndAllowThreads(__tstate);
14168 if (PyErr_Occurred()) SWIG_fail;
14169 }
14170 resultobj = SWIG_From_int(static_cast< int >(result));
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14178 PyObject *resultobj = 0;
14179 wxJoystick *arg1 = (wxJoystick *) 0 ;
14180 int result;
14181 void *argp1 = 0 ;
14182 int res1 = 0 ;
14183 PyObject *swig_obj[1] ;
14184
14185 if (!args) SWIG_fail;
14186 swig_obj[0] = args;
14187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14188 if (!SWIG_IsOK(res1)) {
14189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14190 }
14191 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (int)(arg1)->GetMovementThreshold();
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 resultobj = SWIG_From_int(static_cast< int >(result));
14199 return resultobj;
14200 fail:
14201 return NULL;
14202 }
14203
14204
14205 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj = 0;
14207 wxJoystick *arg1 = (wxJoystick *) 0 ;
14208 int arg2 ;
14209 void *argp1 = 0 ;
14210 int res1 = 0 ;
14211 int val2 ;
14212 int ecode2 = 0 ;
14213 PyObject * obj0 = 0 ;
14214 PyObject * obj1 = 0 ;
14215 char * kwnames[] = {
14216 (char *) "self",(char *) "threshold", NULL
14217 };
14218
14219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14221 if (!SWIG_IsOK(res1)) {
14222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14223 }
14224 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14225 ecode2 = SWIG_AsVal_int(obj1, &val2);
14226 if (!SWIG_IsOK(ecode2)) {
14227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14228 }
14229 arg2 = static_cast< int >(val2);
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 (arg1)->SetMovementThreshold(arg2);
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 resultobj = SWIG_Py_Void();
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14244 PyObject *resultobj = 0;
14245 wxJoystick *arg1 = (wxJoystick *) 0 ;
14246 bool result;
14247 void *argp1 = 0 ;
14248 int res1 = 0 ;
14249 PyObject *swig_obj[1] ;
14250
14251 if (!args) SWIG_fail;
14252 swig_obj[0] = args;
14253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14254 if (!SWIG_IsOK(res1)) {
14255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14256 }
14257 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14258 {
14259 PyThreadState* __tstate = wxPyBeginAllowThreads();
14260 result = (bool)(arg1)->IsOk();
14261 wxPyEndAllowThreads(__tstate);
14262 if (PyErr_Occurred()) SWIG_fail;
14263 }
14264 {
14265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14266 }
14267 return resultobj;
14268 fail:
14269 return NULL;
14270 }
14271
14272
14273 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14274 PyObject *resultobj = 0;
14275 wxJoystick *arg1 = (wxJoystick *) 0 ;
14276 int result;
14277 void *argp1 = 0 ;
14278 int res1 = 0 ;
14279 PyObject *swig_obj[1] ;
14280
14281 if (!args) SWIG_fail;
14282 swig_obj[0] = args;
14283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14284 if (!SWIG_IsOK(res1)) {
14285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14286 }
14287 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14288 {
14289 PyThreadState* __tstate = wxPyBeginAllowThreads();
14290 result = (int)(arg1)->GetNumberJoysticks();
14291 wxPyEndAllowThreads(__tstate);
14292 if (PyErr_Occurred()) SWIG_fail;
14293 }
14294 resultobj = SWIG_From_int(static_cast< int >(result));
14295 return resultobj;
14296 fail:
14297 return NULL;
14298 }
14299
14300
14301 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14302 PyObject *resultobj = 0;
14303 wxJoystick *arg1 = (wxJoystick *) 0 ;
14304 int result;
14305 void *argp1 = 0 ;
14306 int res1 = 0 ;
14307 PyObject *swig_obj[1] ;
14308
14309 if (!args) SWIG_fail;
14310 swig_obj[0] = args;
14311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14312 if (!SWIG_IsOK(res1)) {
14313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14314 }
14315 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14316 {
14317 PyThreadState* __tstate = wxPyBeginAllowThreads();
14318 result = (int)(arg1)->GetManufacturerId();
14319 wxPyEndAllowThreads(__tstate);
14320 if (PyErr_Occurred()) SWIG_fail;
14321 }
14322 resultobj = SWIG_From_int(static_cast< int >(result));
14323 return resultobj;
14324 fail:
14325 return NULL;
14326 }
14327
14328
14329 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14330 PyObject *resultobj = 0;
14331 wxJoystick *arg1 = (wxJoystick *) 0 ;
14332 int result;
14333 void *argp1 = 0 ;
14334 int res1 = 0 ;
14335 PyObject *swig_obj[1] ;
14336
14337 if (!args) SWIG_fail;
14338 swig_obj[0] = args;
14339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14340 if (!SWIG_IsOK(res1)) {
14341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14342 }
14343 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 result = (int)(arg1)->GetProductId();
14347 wxPyEndAllowThreads(__tstate);
14348 if (PyErr_Occurred()) SWIG_fail;
14349 }
14350 resultobj = SWIG_From_int(static_cast< int >(result));
14351 return resultobj;
14352 fail:
14353 return NULL;
14354 }
14355
14356
14357 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14358 PyObject *resultobj = 0;
14359 wxJoystick *arg1 = (wxJoystick *) 0 ;
14360 wxString result;
14361 void *argp1 = 0 ;
14362 int res1 = 0 ;
14363 PyObject *swig_obj[1] ;
14364
14365 if (!args) SWIG_fail;
14366 swig_obj[0] = args;
14367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14368 if (!SWIG_IsOK(res1)) {
14369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14370 }
14371 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14372 {
14373 PyThreadState* __tstate = wxPyBeginAllowThreads();
14374 result = (arg1)->GetProductName();
14375 wxPyEndAllowThreads(__tstate);
14376 if (PyErr_Occurred()) SWIG_fail;
14377 }
14378 {
14379 #if wxUSE_UNICODE
14380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14381 #else
14382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14383 #endif
14384 }
14385 return resultobj;
14386 fail:
14387 return NULL;
14388 }
14389
14390
14391 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14392 PyObject *resultobj = 0;
14393 wxJoystick *arg1 = (wxJoystick *) 0 ;
14394 int result;
14395 void *argp1 = 0 ;
14396 int res1 = 0 ;
14397 PyObject *swig_obj[1] ;
14398
14399 if (!args) SWIG_fail;
14400 swig_obj[0] = args;
14401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14402 if (!SWIG_IsOK(res1)) {
14403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14404 }
14405 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14406 {
14407 PyThreadState* __tstate = wxPyBeginAllowThreads();
14408 result = (int)(arg1)->GetXMin();
14409 wxPyEndAllowThreads(__tstate);
14410 if (PyErr_Occurred()) SWIG_fail;
14411 }
14412 resultobj = SWIG_From_int(static_cast< int >(result));
14413 return resultobj;
14414 fail:
14415 return NULL;
14416 }
14417
14418
14419 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14420 PyObject *resultobj = 0;
14421 wxJoystick *arg1 = (wxJoystick *) 0 ;
14422 int result;
14423 void *argp1 = 0 ;
14424 int res1 = 0 ;
14425 PyObject *swig_obj[1] ;
14426
14427 if (!args) SWIG_fail;
14428 swig_obj[0] = args;
14429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14430 if (!SWIG_IsOK(res1)) {
14431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14432 }
14433 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14434 {
14435 PyThreadState* __tstate = wxPyBeginAllowThreads();
14436 result = (int)(arg1)->GetYMin();
14437 wxPyEndAllowThreads(__tstate);
14438 if (PyErr_Occurred()) SWIG_fail;
14439 }
14440 resultobj = SWIG_From_int(static_cast< int >(result));
14441 return resultobj;
14442 fail:
14443 return NULL;
14444 }
14445
14446
14447 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14448 PyObject *resultobj = 0;
14449 wxJoystick *arg1 = (wxJoystick *) 0 ;
14450 int result;
14451 void *argp1 = 0 ;
14452 int res1 = 0 ;
14453 PyObject *swig_obj[1] ;
14454
14455 if (!args) SWIG_fail;
14456 swig_obj[0] = args;
14457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14458 if (!SWIG_IsOK(res1)) {
14459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14460 }
14461 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14462 {
14463 PyThreadState* __tstate = wxPyBeginAllowThreads();
14464 result = (int)(arg1)->GetZMin();
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 resultobj = SWIG_From_int(static_cast< int >(result));
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14476 PyObject *resultobj = 0;
14477 wxJoystick *arg1 = (wxJoystick *) 0 ;
14478 int result;
14479 void *argp1 = 0 ;
14480 int res1 = 0 ;
14481 PyObject *swig_obj[1] ;
14482
14483 if (!args) SWIG_fail;
14484 swig_obj[0] = args;
14485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14486 if (!SWIG_IsOK(res1)) {
14487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14488 }
14489 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14490 {
14491 PyThreadState* __tstate = wxPyBeginAllowThreads();
14492 result = (int)(arg1)->GetXMax();
14493 wxPyEndAllowThreads(__tstate);
14494 if (PyErr_Occurred()) SWIG_fail;
14495 }
14496 resultobj = SWIG_From_int(static_cast< int >(result));
14497 return resultobj;
14498 fail:
14499 return NULL;
14500 }
14501
14502
14503 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14504 PyObject *resultobj = 0;
14505 wxJoystick *arg1 = (wxJoystick *) 0 ;
14506 int result;
14507 void *argp1 = 0 ;
14508 int res1 = 0 ;
14509 PyObject *swig_obj[1] ;
14510
14511 if (!args) SWIG_fail;
14512 swig_obj[0] = args;
14513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14514 if (!SWIG_IsOK(res1)) {
14515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14516 }
14517 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14518 {
14519 PyThreadState* __tstate = wxPyBeginAllowThreads();
14520 result = (int)(arg1)->GetYMax();
14521 wxPyEndAllowThreads(__tstate);
14522 if (PyErr_Occurred()) SWIG_fail;
14523 }
14524 resultobj = SWIG_From_int(static_cast< int >(result));
14525 return resultobj;
14526 fail:
14527 return NULL;
14528 }
14529
14530
14531 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14532 PyObject *resultobj = 0;
14533 wxJoystick *arg1 = (wxJoystick *) 0 ;
14534 int result;
14535 void *argp1 = 0 ;
14536 int res1 = 0 ;
14537 PyObject *swig_obj[1] ;
14538
14539 if (!args) SWIG_fail;
14540 swig_obj[0] = args;
14541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14542 if (!SWIG_IsOK(res1)) {
14543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14544 }
14545 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14546 {
14547 PyThreadState* __tstate = wxPyBeginAllowThreads();
14548 result = (int)(arg1)->GetZMax();
14549 wxPyEndAllowThreads(__tstate);
14550 if (PyErr_Occurred()) SWIG_fail;
14551 }
14552 resultobj = SWIG_From_int(static_cast< int >(result));
14553 return resultobj;
14554 fail:
14555 return NULL;
14556 }
14557
14558
14559 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14560 PyObject *resultobj = 0;
14561 wxJoystick *arg1 = (wxJoystick *) 0 ;
14562 int result;
14563 void *argp1 = 0 ;
14564 int res1 = 0 ;
14565 PyObject *swig_obj[1] ;
14566
14567 if (!args) SWIG_fail;
14568 swig_obj[0] = args;
14569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14570 if (!SWIG_IsOK(res1)) {
14571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14572 }
14573 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14574 {
14575 PyThreadState* __tstate = wxPyBeginAllowThreads();
14576 result = (int)(arg1)->GetNumberButtons();
14577 wxPyEndAllowThreads(__tstate);
14578 if (PyErr_Occurred()) SWIG_fail;
14579 }
14580 resultobj = SWIG_From_int(static_cast< int >(result));
14581 return resultobj;
14582 fail:
14583 return NULL;
14584 }
14585
14586
14587 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14588 PyObject *resultobj = 0;
14589 wxJoystick *arg1 = (wxJoystick *) 0 ;
14590 int result;
14591 void *argp1 = 0 ;
14592 int res1 = 0 ;
14593 PyObject *swig_obj[1] ;
14594
14595 if (!args) SWIG_fail;
14596 swig_obj[0] = args;
14597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14598 if (!SWIG_IsOK(res1)) {
14599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14600 }
14601 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14602 {
14603 PyThreadState* __tstate = wxPyBeginAllowThreads();
14604 result = (int)(arg1)->GetNumberAxes();
14605 wxPyEndAllowThreads(__tstate);
14606 if (PyErr_Occurred()) SWIG_fail;
14607 }
14608 resultobj = SWIG_From_int(static_cast< int >(result));
14609 return resultobj;
14610 fail:
14611 return NULL;
14612 }
14613
14614
14615 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14616 PyObject *resultobj = 0;
14617 wxJoystick *arg1 = (wxJoystick *) 0 ;
14618 int result;
14619 void *argp1 = 0 ;
14620 int res1 = 0 ;
14621 PyObject *swig_obj[1] ;
14622
14623 if (!args) SWIG_fail;
14624 swig_obj[0] = args;
14625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14626 if (!SWIG_IsOK(res1)) {
14627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14628 }
14629 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14630 {
14631 PyThreadState* __tstate = wxPyBeginAllowThreads();
14632 result = (int)(arg1)->GetMaxButtons();
14633 wxPyEndAllowThreads(__tstate);
14634 if (PyErr_Occurred()) SWIG_fail;
14635 }
14636 resultobj = SWIG_From_int(static_cast< int >(result));
14637 return resultobj;
14638 fail:
14639 return NULL;
14640 }
14641
14642
14643 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14644 PyObject *resultobj = 0;
14645 wxJoystick *arg1 = (wxJoystick *) 0 ;
14646 int result;
14647 void *argp1 = 0 ;
14648 int res1 = 0 ;
14649 PyObject *swig_obj[1] ;
14650
14651 if (!args) SWIG_fail;
14652 swig_obj[0] = args;
14653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14654 if (!SWIG_IsOK(res1)) {
14655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14656 }
14657 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14658 {
14659 PyThreadState* __tstate = wxPyBeginAllowThreads();
14660 result = (int)(arg1)->GetMaxAxes();
14661 wxPyEndAllowThreads(__tstate);
14662 if (PyErr_Occurred()) SWIG_fail;
14663 }
14664 resultobj = SWIG_From_int(static_cast< int >(result));
14665 return resultobj;
14666 fail:
14667 return NULL;
14668 }
14669
14670
14671 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14672 PyObject *resultobj = 0;
14673 wxJoystick *arg1 = (wxJoystick *) 0 ;
14674 int result;
14675 void *argp1 = 0 ;
14676 int res1 = 0 ;
14677 PyObject *swig_obj[1] ;
14678
14679 if (!args) SWIG_fail;
14680 swig_obj[0] = args;
14681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14682 if (!SWIG_IsOK(res1)) {
14683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14684 }
14685 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14686 {
14687 PyThreadState* __tstate = wxPyBeginAllowThreads();
14688 result = (int)(arg1)->GetPollingMin();
14689 wxPyEndAllowThreads(__tstate);
14690 if (PyErr_Occurred()) SWIG_fail;
14691 }
14692 resultobj = SWIG_From_int(static_cast< int >(result));
14693 return resultobj;
14694 fail:
14695 return NULL;
14696 }
14697
14698
14699 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14700 PyObject *resultobj = 0;
14701 wxJoystick *arg1 = (wxJoystick *) 0 ;
14702 int result;
14703 void *argp1 = 0 ;
14704 int res1 = 0 ;
14705 PyObject *swig_obj[1] ;
14706
14707 if (!args) SWIG_fail;
14708 swig_obj[0] = args;
14709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14710 if (!SWIG_IsOK(res1)) {
14711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14712 }
14713 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 result = (int)(arg1)->GetPollingMax();
14717 wxPyEndAllowThreads(__tstate);
14718 if (PyErr_Occurred()) SWIG_fail;
14719 }
14720 resultobj = SWIG_From_int(static_cast< int >(result));
14721 return resultobj;
14722 fail:
14723 return NULL;
14724 }
14725
14726
14727 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14728 PyObject *resultobj = 0;
14729 wxJoystick *arg1 = (wxJoystick *) 0 ;
14730 int result;
14731 void *argp1 = 0 ;
14732 int res1 = 0 ;
14733 PyObject *swig_obj[1] ;
14734
14735 if (!args) SWIG_fail;
14736 swig_obj[0] = args;
14737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14738 if (!SWIG_IsOK(res1)) {
14739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14740 }
14741 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14742 {
14743 PyThreadState* __tstate = wxPyBeginAllowThreads();
14744 result = (int)(arg1)->GetRudderMin();
14745 wxPyEndAllowThreads(__tstate);
14746 if (PyErr_Occurred()) SWIG_fail;
14747 }
14748 resultobj = SWIG_From_int(static_cast< int >(result));
14749 return resultobj;
14750 fail:
14751 return NULL;
14752 }
14753
14754
14755 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14756 PyObject *resultobj = 0;
14757 wxJoystick *arg1 = (wxJoystick *) 0 ;
14758 int result;
14759 void *argp1 = 0 ;
14760 int res1 = 0 ;
14761 PyObject *swig_obj[1] ;
14762
14763 if (!args) SWIG_fail;
14764 swig_obj[0] = args;
14765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14766 if (!SWIG_IsOK(res1)) {
14767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14768 }
14769 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14770 {
14771 PyThreadState* __tstate = wxPyBeginAllowThreads();
14772 result = (int)(arg1)->GetRudderMax();
14773 wxPyEndAllowThreads(__tstate);
14774 if (PyErr_Occurred()) SWIG_fail;
14775 }
14776 resultobj = SWIG_From_int(static_cast< int >(result));
14777 return resultobj;
14778 fail:
14779 return NULL;
14780 }
14781
14782
14783 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14784 PyObject *resultobj = 0;
14785 wxJoystick *arg1 = (wxJoystick *) 0 ;
14786 int result;
14787 void *argp1 = 0 ;
14788 int res1 = 0 ;
14789 PyObject *swig_obj[1] ;
14790
14791 if (!args) SWIG_fail;
14792 swig_obj[0] = args;
14793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14794 if (!SWIG_IsOK(res1)) {
14795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14796 }
14797 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14798 {
14799 PyThreadState* __tstate = wxPyBeginAllowThreads();
14800 result = (int)(arg1)->GetUMin();
14801 wxPyEndAllowThreads(__tstate);
14802 if (PyErr_Occurred()) SWIG_fail;
14803 }
14804 resultobj = SWIG_From_int(static_cast< int >(result));
14805 return resultobj;
14806 fail:
14807 return NULL;
14808 }
14809
14810
14811 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14812 PyObject *resultobj = 0;
14813 wxJoystick *arg1 = (wxJoystick *) 0 ;
14814 int result;
14815 void *argp1 = 0 ;
14816 int res1 = 0 ;
14817 PyObject *swig_obj[1] ;
14818
14819 if (!args) SWIG_fail;
14820 swig_obj[0] = args;
14821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14822 if (!SWIG_IsOK(res1)) {
14823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14824 }
14825 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14826 {
14827 PyThreadState* __tstate = wxPyBeginAllowThreads();
14828 result = (int)(arg1)->GetUMax();
14829 wxPyEndAllowThreads(__tstate);
14830 if (PyErr_Occurred()) SWIG_fail;
14831 }
14832 resultobj = SWIG_From_int(static_cast< int >(result));
14833 return resultobj;
14834 fail:
14835 return NULL;
14836 }
14837
14838
14839 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14840 PyObject *resultobj = 0;
14841 wxJoystick *arg1 = (wxJoystick *) 0 ;
14842 int result;
14843 void *argp1 = 0 ;
14844 int res1 = 0 ;
14845 PyObject *swig_obj[1] ;
14846
14847 if (!args) SWIG_fail;
14848 swig_obj[0] = args;
14849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14850 if (!SWIG_IsOK(res1)) {
14851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14852 }
14853 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 result = (int)(arg1)->GetVMin();
14857 wxPyEndAllowThreads(__tstate);
14858 if (PyErr_Occurred()) SWIG_fail;
14859 }
14860 resultobj = SWIG_From_int(static_cast< int >(result));
14861 return resultobj;
14862 fail:
14863 return NULL;
14864 }
14865
14866
14867 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14868 PyObject *resultobj = 0;
14869 wxJoystick *arg1 = (wxJoystick *) 0 ;
14870 int result;
14871 void *argp1 = 0 ;
14872 int res1 = 0 ;
14873 PyObject *swig_obj[1] ;
14874
14875 if (!args) SWIG_fail;
14876 swig_obj[0] = args;
14877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14878 if (!SWIG_IsOK(res1)) {
14879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14880 }
14881 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14882 {
14883 PyThreadState* __tstate = wxPyBeginAllowThreads();
14884 result = (int)(arg1)->GetVMax();
14885 wxPyEndAllowThreads(__tstate);
14886 if (PyErr_Occurred()) SWIG_fail;
14887 }
14888 resultobj = SWIG_From_int(static_cast< int >(result));
14889 return resultobj;
14890 fail:
14891 return NULL;
14892 }
14893
14894
14895 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14896 PyObject *resultobj = 0;
14897 wxJoystick *arg1 = (wxJoystick *) 0 ;
14898 bool result;
14899 void *argp1 = 0 ;
14900 int res1 = 0 ;
14901 PyObject *swig_obj[1] ;
14902
14903 if (!args) SWIG_fail;
14904 swig_obj[0] = args;
14905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14906 if (!SWIG_IsOK(res1)) {
14907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14908 }
14909 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14910 {
14911 PyThreadState* __tstate = wxPyBeginAllowThreads();
14912 result = (bool)(arg1)->HasRudder();
14913 wxPyEndAllowThreads(__tstate);
14914 if (PyErr_Occurred()) SWIG_fail;
14915 }
14916 {
14917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14918 }
14919 return resultobj;
14920 fail:
14921 return NULL;
14922 }
14923
14924
14925 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14926 PyObject *resultobj = 0;
14927 wxJoystick *arg1 = (wxJoystick *) 0 ;
14928 bool result;
14929 void *argp1 = 0 ;
14930 int res1 = 0 ;
14931 PyObject *swig_obj[1] ;
14932
14933 if (!args) SWIG_fail;
14934 swig_obj[0] = args;
14935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14936 if (!SWIG_IsOK(res1)) {
14937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14938 }
14939 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (bool)(arg1)->HasZ();
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 {
14947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14948 }
14949 return resultobj;
14950 fail:
14951 return NULL;
14952 }
14953
14954
14955 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14956 PyObject *resultobj = 0;
14957 wxJoystick *arg1 = (wxJoystick *) 0 ;
14958 bool result;
14959 void *argp1 = 0 ;
14960 int res1 = 0 ;
14961 PyObject *swig_obj[1] ;
14962
14963 if (!args) SWIG_fail;
14964 swig_obj[0] = args;
14965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14966 if (!SWIG_IsOK(res1)) {
14967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14968 }
14969 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14970 {
14971 PyThreadState* __tstate = wxPyBeginAllowThreads();
14972 result = (bool)(arg1)->HasU();
14973 wxPyEndAllowThreads(__tstate);
14974 if (PyErr_Occurred()) SWIG_fail;
14975 }
14976 {
14977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14978 }
14979 return resultobj;
14980 fail:
14981 return NULL;
14982 }
14983
14984
14985 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14986 PyObject *resultobj = 0;
14987 wxJoystick *arg1 = (wxJoystick *) 0 ;
14988 bool result;
14989 void *argp1 = 0 ;
14990 int res1 = 0 ;
14991 PyObject *swig_obj[1] ;
14992
14993 if (!args) SWIG_fail;
14994 swig_obj[0] = args;
14995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14996 if (!SWIG_IsOK(res1)) {
14997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
14998 }
14999 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 result = (bool)(arg1)->HasV();
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 {
15007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15008 }
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15016 PyObject *resultobj = 0;
15017 wxJoystick *arg1 = (wxJoystick *) 0 ;
15018 bool result;
15019 void *argp1 = 0 ;
15020 int res1 = 0 ;
15021 PyObject *swig_obj[1] ;
15022
15023 if (!args) SWIG_fail;
15024 swig_obj[0] = args;
15025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15026 if (!SWIG_IsOK(res1)) {
15027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15028 }
15029 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15030 {
15031 PyThreadState* __tstate = wxPyBeginAllowThreads();
15032 result = (bool)(arg1)->HasPOV();
15033 wxPyEndAllowThreads(__tstate);
15034 if (PyErr_Occurred()) SWIG_fail;
15035 }
15036 {
15037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15038 }
15039 return resultobj;
15040 fail:
15041 return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15046 PyObject *resultobj = 0;
15047 wxJoystick *arg1 = (wxJoystick *) 0 ;
15048 bool result;
15049 void *argp1 = 0 ;
15050 int res1 = 0 ;
15051 PyObject *swig_obj[1] ;
15052
15053 if (!args) SWIG_fail;
15054 swig_obj[0] = args;
15055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15056 if (!SWIG_IsOK(res1)) {
15057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15058 }
15059 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15060 {
15061 PyThreadState* __tstate = wxPyBeginAllowThreads();
15062 result = (bool)(arg1)->HasPOV4Dir();
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 {
15067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15068 }
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15076 PyObject *resultobj = 0;
15077 wxJoystick *arg1 = (wxJoystick *) 0 ;
15078 bool result;
15079 void *argp1 = 0 ;
15080 int res1 = 0 ;
15081 PyObject *swig_obj[1] ;
15082
15083 if (!args) SWIG_fail;
15084 swig_obj[0] = args;
15085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15088 }
15089 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 result = (bool)(arg1)->HasPOVCTS();
15093 wxPyEndAllowThreads(__tstate);
15094 if (PyErr_Occurred()) SWIG_fail;
15095 }
15096 {
15097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15098 }
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15106 PyObject *resultobj = 0;
15107 wxJoystick *arg1 = (wxJoystick *) 0 ;
15108 wxWindow *arg2 = (wxWindow *) 0 ;
15109 int arg3 = (int) 0 ;
15110 bool result;
15111 void *argp1 = 0 ;
15112 int res1 = 0 ;
15113 void *argp2 = 0 ;
15114 int res2 = 0 ;
15115 int val3 ;
15116 int ecode3 = 0 ;
15117 PyObject * obj0 = 0 ;
15118 PyObject * obj1 = 0 ;
15119 PyObject * obj2 = 0 ;
15120 char * kwnames[] = {
15121 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15122 };
15123
15124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15126 if (!SWIG_IsOK(res1)) {
15127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15128 }
15129 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15130 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15131 if (!SWIG_IsOK(res2)) {
15132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15133 }
15134 arg2 = reinterpret_cast< wxWindow * >(argp2);
15135 if (obj2) {
15136 ecode3 = SWIG_AsVal_int(obj2, &val3);
15137 if (!SWIG_IsOK(ecode3)) {
15138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15139 }
15140 arg3 = static_cast< int >(val3);
15141 }
15142 {
15143 PyThreadState* __tstate = wxPyBeginAllowThreads();
15144 result = (bool)(arg1)->SetCapture(arg2,arg3);
15145 wxPyEndAllowThreads(__tstate);
15146 if (PyErr_Occurred()) SWIG_fail;
15147 }
15148 {
15149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15150 }
15151 return resultobj;
15152 fail:
15153 return NULL;
15154 }
15155
15156
15157 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15158 PyObject *resultobj = 0;
15159 wxJoystick *arg1 = (wxJoystick *) 0 ;
15160 bool result;
15161 void *argp1 = 0 ;
15162 int res1 = 0 ;
15163 PyObject *swig_obj[1] ;
15164
15165 if (!args) SWIG_fail;
15166 swig_obj[0] = args;
15167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15168 if (!SWIG_IsOK(res1)) {
15169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15170 }
15171 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 result = (bool)(arg1)->ReleaseCapture();
15175 wxPyEndAllowThreads(__tstate);
15176 if (PyErr_Occurred()) SWIG_fail;
15177 }
15178 {
15179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15180 }
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15188 PyObject *obj;
15189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15190 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15191 return SWIG_Py_Void();
15192 }
15193
15194 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15195 return SWIG_Python_InitShadowInstance(args);
15196 }
15197
15198 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15199 PyObject *resultobj = 0;
15200 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15201 int arg2 = (int) 0 ;
15202 int arg3 = (int) wxJOYSTICK1 ;
15203 int arg4 = (int) 0 ;
15204 wxJoystickEvent *result = 0 ;
15205 int val1 ;
15206 int ecode1 = 0 ;
15207 int val2 ;
15208 int ecode2 = 0 ;
15209 int val3 ;
15210 int ecode3 = 0 ;
15211 int val4 ;
15212 int ecode4 = 0 ;
15213 PyObject * obj0 = 0 ;
15214 PyObject * obj1 = 0 ;
15215 PyObject * obj2 = 0 ;
15216 PyObject * obj3 = 0 ;
15217 char * kwnames[] = {
15218 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15219 };
15220
15221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15222 if (obj0) {
15223 ecode1 = SWIG_AsVal_int(obj0, &val1);
15224 if (!SWIG_IsOK(ecode1)) {
15225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15226 }
15227 arg1 = static_cast< wxEventType >(val1);
15228 }
15229 if (obj1) {
15230 ecode2 = SWIG_AsVal_int(obj1, &val2);
15231 if (!SWIG_IsOK(ecode2)) {
15232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15233 }
15234 arg2 = static_cast< int >(val2);
15235 }
15236 if (obj2) {
15237 ecode3 = SWIG_AsVal_int(obj2, &val3);
15238 if (!SWIG_IsOK(ecode3)) {
15239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15240 }
15241 arg3 = static_cast< int >(val3);
15242 }
15243 if (obj3) {
15244 ecode4 = SWIG_AsVal_int(obj3, &val4);
15245 if (!SWIG_IsOK(ecode4)) {
15246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15247 }
15248 arg4 = static_cast< int >(val4);
15249 }
15250 {
15251 PyThreadState* __tstate = wxPyBeginAllowThreads();
15252 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15253 wxPyEndAllowThreads(__tstate);
15254 if (PyErr_Occurred()) SWIG_fail;
15255 }
15256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15257 return resultobj;
15258 fail:
15259 return NULL;
15260 }
15261
15262
15263 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15264 PyObject *resultobj = 0;
15265 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15266 wxPoint result;
15267 void *argp1 = 0 ;
15268 int res1 = 0 ;
15269 PyObject *swig_obj[1] ;
15270
15271 if (!args) SWIG_fail;
15272 swig_obj[0] = args;
15273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15274 if (!SWIG_IsOK(res1)) {
15275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15276 }
15277 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15278 {
15279 PyThreadState* __tstate = wxPyBeginAllowThreads();
15280 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15292 PyObject *resultobj = 0;
15293 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15294 int result;
15295 void *argp1 = 0 ;
15296 int res1 = 0 ;
15297 PyObject *swig_obj[1] ;
15298
15299 if (!args) SWIG_fail;
15300 swig_obj[0] = args;
15301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15302 if (!SWIG_IsOK(res1)) {
15303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15304 }
15305 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 resultobj = SWIG_From_int(static_cast< int >(result));
15313 return resultobj;
15314 fail:
15315 return NULL;
15316 }
15317
15318
15319 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15320 PyObject *resultobj = 0;
15321 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15322 int result;
15323 void *argp1 = 0 ;
15324 int res1 = 0 ;
15325 PyObject *swig_obj[1] ;
15326
15327 if (!args) SWIG_fail;
15328 swig_obj[0] = args;
15329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15330 if (!SWIG_IsOK(res1)) {
15331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15332 }
15333 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 resultobj = SWIG_From_int(static_cast< int >(result));
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15348 PyObject *resultobj = 0;
15349 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15350 int result;
15351 void *argp1 = 0 ;
15352 int res1 = 0 ;
15353 PyObject *swig_obj[1] ;
15354
15355 if (!args) SWIG_fail;
15356 swig_obj[0] = args;
15357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15358 if (!SWIG_IsOK(res1)) {
15359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15360 }
15361 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15365 wxPyEndAllowThreads(__tstate);
15366 if (PyErr_Occurred()) SWIG_fail;
15367 }
15368 resultobj = SWIG_From_int(static_cast< int >(result));
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15376 PyObject *resultobj = 0;
15377 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15378 int result;
15379 void *argp1 = 0 ;
15380 int res1 = 0 ;
15381 PyObject *swig_obj[1] ;
15382
15383 if (!args) SWIG_fail;
15384 swig_obj[0] = args;
15385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15386 if (!SWIG_IsOK(res1)) {
15387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15388 }
15389 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15390 {
15391 PyThreadState* __tstate = wxPyBeginAllowThreads();
15392 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15393 wxPyEndAllowThreads(__tstate);
15394 if (PyErr_Occurred()) SWIG_fail;
15395 }
15396 resultobj = SWIG_From_int(static_cast< int >(result));
15397 return resultobj;
15398 fail:
15399 return NULL;
15400 }
15401
15402
15403 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15404 PyObject *resultobj = 0;
15405 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15406 int arg2 ;
15407 void *argp1 = 0 ;
15408 int res1 = 0 ;
15409 int val2 ;
15410 int ecode2 = 0 ;
15411 PyObject * obj0 = 0 ;
15412 PyObject * obj1 = 0 ;
15413 char * kwnames[] = {
15414 (char *) "self",(char *) "stick", NULL
15415 };
15416
15417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15419 if (!SWIG_IsOK(res1)) {
15420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15421 }
15422 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15423 ecode2 = SWIG_AsVal_int(obj1, &val2);
15424 if (!SWIG_IsOK(ecode2)) {
15425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15426 }
15427 arg2 = static_cast< int >(val2);
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 (arg1)->SetJoystick(arg2);
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 resultobj = SWIG_Py_Void();
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj = 0;
15443 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15444 int arg2 ;
15445 void *argp1 = 0 ;
15446 int res1 = 0 ;
15447 int val2 ;
15448 int ecode2 = 0 ;
15449 PyObject * obj0 = 0 ;
15450 PyObject * obj1 = 0 ;
15451 char * kwnames[] = {
15452 (char *) "self",(char *) "state", NULL
15453 };
15454
15455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15459 }
15460 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15461 ecode2 = SWIG_AsVal_int(obj1, &val2);
15462 if (!SWIG_IsOK(ecode2)) {
15463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15464 }
15465 arg2 = static_cast< int >(val2);
15466 {
15467 PyThreadState* __tstate = wxPyBeginAllowThreads();
15468 (arg1)->SetButtonState(arg2);
15469 wxPyEndAllowThreads(__tstate);
15470 if (PyErr_Occurred()) SWIG_fail;
15471 }
15472 resultobj = SWIG_Py_Void();
15473 return resultobj;
15474 fail:
15475 return NULL;
15476 }
15477
15478
15479 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15480 PyObject *resultobj = 0;
15481 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15482 int arg2 ;
15483 void *argp1 = 0 ;
15484 int res1 = 0 ;
15485 int val2 ;
15486 int ecode2 = 0 ;
15487 PyObject * obj0 = 0 ;
15488 PyObject * obj1 = 0 ;
15489 char * kwnames[] = {
15490 (char *) "self",(char *) "change", NULL
15491 };
15492
15493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15495 if (!SWIG_IsOK(res1)) {
15496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15497 }
15498 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15499 ecode2 = SWIG_AsVal_int(obj1, &val2);
15500 if (!SWIG_IsOK(ecode2)) {
15501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15502 }
15503 arg2 = static_cast< int >(val2);
15504 {
15505 PyThreadState* __tstate = wxPyBeginAllowThreads();
15506 (arg1)->SetButtonChange(arg2);
15507 wxPyEndAllowThreads(__tstate);
15508 if (PyErr_Occurred()) SWIG_fail;
15509 }
15510 resultobj = SWIG_Py_Void();
15511 return resultobj;
15512 fail:
15513 return NULL;
15514 }
15515
15516
15517 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15518 PyObject *resultobj = 0;
15519 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15520 wxPoint *arg2 = 0 ;
15521 void *argp1 = 0 ;
15522 int res1 = 0 ;
15523 wxPoint temp2 ;
15524 PyObject * obj0 = 0 ;
15525 PyObject * obj1 = 0 ;
15526 char * kwnames[] = {
15527 (char *) "self",(char *) "pos", NULL
15528 };
15529
15530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15532 if (!SWIG_IsOK(res1)) {
15533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15534 }
15535 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15536 {
15537 arg2 = &temp2;
15538 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15539 }
15540 {
15541 PyThreadState* __tstate = wxPyBeginAllowThreads();
15542 (arg1)->SetPosition((wxPoint const &)*arg2);
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 resultobj = SWIG_Py_Void();
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj = 0;
15555 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15556 int arg2 ;
15557 void *argp1 = 0 ;
15558 int res1 = 0 ;
15559 int val2 ;
15560 int ecode2 = 0 ;
15561 PyObject * obj0 = 0 ;
15562 PyObject * obj1 = 0 ;
15563 char * kwnames[] = {
15564 (char *) "self",(char *) "zPos", NULL
15565 };
15566
15567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15569 if (!SWIG_IsOK(res1)) {
15570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15571 }
15572 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15573 ecode2 = SWIG_AsVal_int(obj1, &val2);
15574 if (!SWIG_IsOK(ecode2)) {
15575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15576 }
15577 arg2 = static_cast< int >(val2);
15578 {
15579 PyThreadState* __tstate = wxPyBeginAllowThreads();
15580 (arg1)->SetZPosition(arg2);
15581 wxPyEndAllowThreads(__tstate);
15582 if (PyErr_Occurred()) SWIG_fail;
15583 }
15584 resultobj = SWIG_Py_Void();
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15592 PyObject *resultobj = 0;
15593 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15594 bool result;
15595 void *argp1 = 0 ;
15596 int res1 = 0 ;
15597 PyObject *swig_obj[1] ;
15598
15599 if (!args) SWIG_fail;
15600 swig_obj[0] = args;
15601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15602 if (!SWIG_IsOK(res1)) {
15603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15604 }
15605 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 {
15613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15614 }
15615 return resultobj;
15616 fail:
15617 return NULL;
15618 }
15619
15620
15621 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15622 PyObject *resultobj = 0;
15623 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15624 bool result;
15625 void *argp1 = 0 ;
15626 int res1 = 0 ;
15627 PyObject *swig_obj[1] ;
15628
15629 if (!args) SWIG_fail;
15630 swig_obj[0] = args;
15631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15632 if (!SWIG_IsOK(res1)) {
15633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15634 }
15635 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15636 {
15637 PyThreadState* __tstate = wxPyBeginAllowThreads();
15638 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15639 wxPyEndAllowThreads(__tstate);
15640 if (PyErr_Occurred()) SWIG_fail;
15641 }
15642 {
15643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15644 }
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15652 PyObject *resultobj = 0;
15653 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15654 bool result;
15655 void *argp1 = 0 ;
15656 int res1 = 0 ;
15657 PyObject *swig_obj[1] ;
15658
15659 if (!args) SWIG_fail;
15660 swig_obj[0] = args;
15661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15662 if (!SWIG_IsOK(res1)) {
15663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15664 }
15665 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 {
15673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15674 }
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj = 0;
15683 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15684 int arg2 = (int) wxJOY_BUTTON_ANY ;
15685 bool result;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 int val2 ;
15689 int ecode2 = 0 ;
15690 PyObject * obj0 = 0 ;
15691 PyObject * obj1 = 0 ;
15692 char * kwnames[] = {
15693 (char *) "self",(char *) "but", NULL
15694 };
15695
15696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15698 if (!SWIG_IsOK(res1)) {
15699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15700 }
15701 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15702 if (obj1) {
15703 ecode2 = SWIG_AsVal_int(obj1, &val2);
15704 if (!SWIG_IsOK(ecode2)) {
15705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15706 }
15707 arg2 = static_cast< int >(val2);
15708 }
15709 {
15710 PyThreadState* __tstate = wxPyBeginAllowThreads();
15711 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 {
15716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15717 }
15718 return resultobj;
15719 fail:
15720 return NULL;
15721 }
15722
15723
15724 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15725 PyObject *resultobj = 0;
15726 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15727 int arg2 = (int) wxJOY_BUTTON_ANY ;
15728 bool result;
15729 void *argp1 = 0 ;
15730 int res1 = 0 ;
15731 int val2 ;
15732 int ecode2 = 0 ;
15733 PyObject * obj0 = 0 ;
15734 PyObject * obj1 = 0 ;
15735 char * kwnames[] = {
15736 (char *) "self",(char *) "but", NULL
15737 };
15738
15739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15741 if (!SWIG_IsOK(res1)) {
15742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15743 }
15744 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15745 if (obj1) {
15746 ecode2 = SWIG_AsVal_int(obj1, &val2);
15747 if (!SWIG_IsOK(ecode2)) {
15748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15749 }
15750 arg2 = static_cast< int >(val2);
15751 }
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 {
15759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15760 }
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj = 0;
15769 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15770 int arg2 = (int) wxJOY_BUTTON_ANY ;
15771 bool result;
15772 void *argp1 = 0 ;
15773 int res1 = 0 ;
15774 int val2 ;
15775 int ecode2 = 0 ;
15776 PyObject * obj0 = 0 ;
15777 PyObject * obj1 = 0 ;
15778 char * kwnames[] = {
15779 (char *) "self",(char *) "but", NULL
15780 };
15781
15782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15784 if (!SWIG_IsOK(res1)) {
15785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15786 }
15787 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15788 if (obj1) {
15789 ecode2 = SWIG_AsVal_int(obj1, &val2);
15790 if (!SWIG_IsOK(ecode2)) {
15791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15792 }
15793 arg2 = static_cast< int >(val2);
15794 }
15795 {
15796 PyThreadState* __tstate = wxPyBeginAllowThreads();
15797 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 {
15802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15803 }
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15811 PyObject *obj;
15812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15813 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15814 return SWIG_Py_Void();
15815 }
15816
15817 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15818 return SWIG_Python_InitShadowInstance(args);
15819 }
15820
15821 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15822 PyObject *resultobj = 0;
15823 wxString const &arg1_defvalue = wxPyEmptyString ;
15824 wxString *arg1 = (wxString *) &arg1_defvalue ;
15825 wxSound *result = 0 ;
15826 bool temp1 = false ;
15827 PyObject * obj0 = 0 ;
15828 char * kwnames[] = {
15829 (char *) "fileName", NULL
15830 };
15831
15832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15833 if (obj0) {
15834 {
15835 arg1 = wxString_in_helper(obj0);
15836 if (arg1 == NULL) SWIG_fail;
15837 temp1 = true;
15838 }
15839 }
15840 {
15841 if (!wxPyCheckForApp()) SWIG_fail;
15842 PyThreadState* __tstate = wxPyBeginAllowThreads();
15843 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15844 wxPyEndAllowThreads(__tstate);
15845 if (PyErr_Occurred()) SWIG_fail;
15846 }
15847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15848 {
15849 if (temp1)
15850 delete arg1;
15851 }
15852 return resultobj;
15853 fail:
15854 {
15855 if (temp1)
15856 delete arg1;
15857 }
15858 return NULL;
15859 }
15860
15861
15862 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15863 PyObject *resultobj = 0;
15864 PyObject *arg1 = (PyObject *) 0 ;
15865 wxSound *result = 0 ;
15866 PyObject * obj0 = 0 ;
15867 char * kwnames[] = {
15868 (char *) "data", NULL
15869 };
15870
15871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15872 arg1 = obj0;
15873 {
15874 if (!wxPyCheckForApp()) SWIG_fail;
15875 PyThreadState* __tstate = wxPyBeginAllowThreads();
15876 result = (wxSound *)new_wxSound(arg1);
15877 wxPyEndAllowThreads(__tstate);
15878 if (PyErr_Occurred()) SWIG_fail;
15879 }
15880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15881 return resultobj;
15882 fail:
15883 return NULL;
15884 }
15885
15886
15887 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15888 PyObject *resultobj = 0;
15889 wxSound *arg1 = (wxSound *) 0 ;
15890 void *argp1 = 0 ;
15891 int res1 = 0 ;
15892 PyObject *swig_obj[1] ;
15893
15894 if (!args) SWIG_fail;
15895 swig_obj[0] = args;
15896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15897 if (!SWIG_IsOK(res1)) {
15898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15899 }
15900 arg1 = reinterpret_cast< wxSound * >(argp1);
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 delete arg1;
15904
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 resultobj = SWIG_Py_Void();
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15916 PyObject *resultobj = 0;
15917 wxSound *arg1 = (wxSound *) 0 ;
15918 wxString *arg2 = 0 ;
15919 bool result;
15920 void *argp1 = 0 ;
15921 int res1 = 0 ;
15922 bool temp2 = false ;
15923 PyObject * obj0 = 0 ;
15924 PyObject * obj1 = 0 ;
15925 char * kwnames[] = {
15926 (char *) "self",(char *) "fileName", NULL
15927 };
15928
15929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15931 if (!SWIG_IsOK(res1)) {
15932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15933 }
15934 arg1 = reinterpret_cast< wxSound * >(argp1);
15935 {
15936 arg2 = wxString_in_helper(obj1);
15937 if (arg2 == NULL) SWIG_fail;
15938 temp2 = true;
15939 }
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 result = (bool)(arg1)->Create((wxString const &)*arg2);
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 {
15947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15948 }
15949 {
15950 if (temp2)
15951 delete arg2;
15952 }
15953 return resultobj;
15954 fail:
15955 {
15956 if (temp2)
15957 delete arg2;
15958 }
15959 return NULL;
15960 }
15961
15962
15963 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj = 0;
15965 wxSound *arg1 = (wxSound *) 0 ;
15966 PyObject *arg2 = (PyObject *) 0 ;
15967 bool result;
15968 void *argp1 = 0 ;
15969 int res1 = 0 ;
15970 PyObject * obj0 = 0 ;
15971 PyObject * obj1 = 0 ;
15972 char * kwnames[] = {
15973 (char *) "self",(char *) "data", NULL
15974 };
15975
15976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15978 if (!SWIG_IsOK(res1)) {
15979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15980 }
15981 arg1 = reinterpret_cast< wxSound * >(argp1);
15982 arg2 = obj1;
15983 {
15984 PyThreadState* __tstate = wxPyBeginAllowThreads();
15985 result = (bool)wxSound_CreateFromData(arg1,arg2);
15986 wxPyEndAllowThreads(__tstate);
15987 if (PyErr_Occurred()) SWIG_fail;
15988 }
15989 {
15990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15991 }
15992 return resultobj;
15993 fail:
15994 return NULL;
15995 }
15996
15997
15998 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15999 PyObject *resultobj = 0;
16000 wxSound *arg1 = (wxSound *) 0 ;
16001 bool result;
16002 void *argp1 = 0 ;
16003 int res1 = 0 ;
16004 PyObject *swig_obj[1] ;
16005
16006 if (!args) SWIG_fail;
16007 swig_obj[0] = args;
16008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16009 if (!SWIG_IsOK(res1)) {
16010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16011 }
16012 arg1 = reinterpret_cast< wxSound * >(argp1);
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (bool)(arg1)->IsOk();
16016 wxPyEndAllowThreads(__tstate);
16017 if (PyErr_Occurred()) SWIG_fail;
16018 }
16019 {
16020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16021 }
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16029 PyObject *resultobj = 0;
16030 wxSound *arg1 = (wxSound *) 0 ;
16031 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16032 bool result;
16033 void *argp1 = 0 ;
16034 int res1 = 0 ;
16035 unsigned int val2 ;
16036 int ecode2 = 0 ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 char * kwnames[] = {
16040 (char *) "self",(char *) "flags", NULL
16041 };
16042
16043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16045 if (!SWIG_IsOK(res1)) {
16046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16047 }
16048 arg1 = reinterpret_cast< wxSound * >(argp1);
16049 if (obj1) {
16050 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16051 if (!SWIG_IsOK(ecode2)) {
16052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16053 }
16054 arg2 = static_cast< unsigned int >(val2);
16055 }
16056 {
16057 if (!wxPyCheckForApp()) SWIG_fail;
16058 PyThreadState* __tstate = wxPyBeginAllowThreads();
16059 result = (bool)((wxSound const *)arg1)->Play(arg2);
16060 wxPyEndAllowThreads(__tstate);
16061 if (PyErr_Occurred()) SWIG_fail;
16062 }
16063 {
16064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16065 }
16066 return resultobj;
16067 fail:
16068 return NULL;
16069 }
16070
16071
16072 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16073 PyObject *resultobj = 0;
16074 wxString *arg1 = 0 ;
16075 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16076 bool result;
16077 bool temp1 = false ;
16078 unsigned int val2 ;
16079 int ecode2 = 0 ;
16080 PyObject * obj0 = 0 ;
16081 PyObject * obj1 = 0 ;
16082 char * kwnames[] = {
16083 (char *) "filename",(char *) "flags", NULL
16084 };
16085
16086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16087 {
16088 arg1 = wxString_in_helper(obj0);
16089 if (arg1 == NULL) SWIG_fail;
16090 temp1 = true;
16091 }
16092 if (obj1) {
16093 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16094 if (!SWIG_IsOK(ecode2)) {
16095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16096 }
16097 arg2 = static_cast< unsigned int >(val2);
16098 }
16099 {
16100 if (!wxPyCheckForApp()) SWIG_fail;
16101 PyThreadState* __tstate = wxPyBeginAllowThreads();
16102 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 {
16107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16108 }
16109 {
16110 if (temp1)
16111 delete arg1;
16112 }
16113 return resultobj;
16114 fail:
16115 {
16116 if (temp1)
16117 delete arg1;
16118 }
16119 return NULL;
16120 }
16121
16122
16123 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16124 PyObject *resultobj = 0;
16125
16126 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16127 {
16128 if (!wxPyCheckForApp()) SWIG_fail;
16129 PyThreadState* __tstate = wxPyBeginAllowThreads();
16130 wxSound::Stop();
16131 wxPyEndAllowThreads(__tstate);
16132 if (PyErr_Occurred()) SWIG_fail;
16133 }
16134 resultobj = SWIG_Py_Void();
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16142 PyObject *obj;
16143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16144 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16145 return SWIG_Py_Void();
16146 }
16147
16148 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16149 return SWIG_Python_InitShadowInstance(args);
16150 }
16151
16152 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16153 PyObject *resultobj = 0;
16154 wxString *arg1 = 0 ;
16155 wxString *arg2 = 0 ;
16156 wxString *arg3 = 0 ;
16157 wxString *arg4 = 0 ;
16158 wxFileTypeInfo *result = 0 ;
16159 bool temp1 = false ;
16160 bool temp2 = false ;
16161 bool temp3 = false ;
16162 bool temp4 = false ;
16163 PyObject * obj0 = 0 ;
16164 PyObject * obj1 = 0 ;
16165 PyObject * obj2 = 0 ;
16166 PyObject * obj3 = 0 ;
16167 char * kwnames[] = {
16168 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16169 };
16170
16171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16172 {
16173 arg1 = wxString_in_helper(obj0);
16174 if (arg1 == NULL) SWIG_fail;
16175 temp1 = true;
16176 }
16177 {
16178 arg2 = wxString_in_helper(obj1);
16179 if (arg2 == NULL) SWIG_fail;
16180 temp2 = true;
16181 }
16182 {
16183 arg3 = wxString_in_helper(obj2);
16184 if (arg3 == NULL) SWIG_fail;
16185 temp3 = true;
16186 }
16187 {
16188 arg4 = wxString_in_helper(obj3);
16189 if (arg4 == NULL) SWIG_fail;
16190 temp4 = true;
16191 }
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16199 {
16200 if (temp1)
16201 delete arg1;
16202 }
16203 {
16204 if (temp2)
16205 delete arg2;
16206 }
16207 {
16208 if (temp3)
16209 delete arg3;
16210 }
16211 {
16212 if (temp4)
16213 delete arg4;
16214 }
16215 return resultobj;
16216 fail:
16217 {
16218 if (temp1)
16219 delete arg1;
16220 }
16221 {
16222 if (temp2)
16223 delete arg2;
16224 }
16225 {
16226 if (temp3)
16227 delete arg3;
16228 }
16229 {
16230 if (temp4)
16231 delete arg4;
16232 }
16233 return NULL;
16234 }
16235
16236
16237 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16238 PyObject *resultobj = 0;
16239 wxArrayString *arg1 = 0 ;
16240 wxFileTypeInfo *result = 0 ;
16241 bool temp1 = false ;
16242 PyObject * obj0 = 0 ;
16243 char * kwnames[] = {
16244 (char *) "sArray", NULL
16245 };
16246
16247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16248 {
16249 if (! PySequence_Check(obj0)) {
16250 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16251 SWIG_fail;
16252 }
16253 arg1 = new wxArrayString;
16254 temp1 = true;
16255 int i, len=PySequence_Length(obj0);
16256 for (i=0; i<len; i++) {
16257 PyObject* item = PySequence_GetItem(obj0, i);
16258 wxString* s = wxString_in_helper(item);
16259 if (PyErr_Occurred()) SWIG_fail;
16260 arg1->Add(*s);
16261 delete s;
16262 Py_DECREF(item);
16263 }
16264 }
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16268 wxPyEndAllowThreads(__tstate);
16269 if (PyErr_Occurred()) SWIG_fail;
16270 }
16271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16272 {
16273 if (temp1) delete arg1;
16274 }
16275 return resultobj;
16276 fail:
16277 {
16278 if (temp1) delete arg1;
16279 }
16280 return NULL;
16281 }
16282
16283
16284 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16285 PyObject *resultobj = 0;
16286 wxFileTypeInfo *result = 0 ;
16287
16288 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16289 {
16290 PyThreadState* __tstate = wxPyBeginAllowThreads();
16291 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16296 return resultobj;
16297 fail:
16298 return NULL;
16299 }
16300
16301
16302 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16303 PyObject *resultobj = 0;
16304 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16305 bool result;
16306 void *argp1 = 0 ;
16307 int res1 = 0 ;
16308 PyObject *swig_obj[1] ;
16309
16310 if (!args) SWIG_fail;
16311 swig_obj[0] = args;
16312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16313 if (!SWIG_IsOK(res1)) {
16314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16315 }
16316 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 {
16324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16325 }
16326 return resultobj;
16327 fail:
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj = 0;
16334 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16335 wxString *arg2 = 0 ;
16336 int arg3 = (int) 0 ;
16337 void *argp1 = 0 ;
16338 int res1 = 0 ;
16339 bool temp2 = false ;
16340 int val3 ;
16341 int ecode3 = 0 ;
16342 PyObject * obj0 = 0 ;
16343 PyObject * obj1 = 0 ;
16344 PyObject * obj2 = 0 ;
16345 char * kwnames[] = {
16346 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16347 };
16348
16349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16351 if (!SWIG_IsOK(res1)) {
16352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16353 }
16354 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16355 {
16356 arg2 = wxString_in_helper(obj1);
16357 if (arg2 == NULL) SWIG_fail;
16358 temp2 = true;
16359 }
16360 if (obj2) {
16361 ecode3 = SWIG_AsVal_int(obj2, &val3);
16362 if (!SWIG_IsOK(ecode3)) {
16363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16364 }
16365 arg3 = static_cast< int >(val3);
16366 }
16367 {
16368 PyThreadState* __tstate = wxPyBeginAllowThreads();
16369 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16370 wxPyEndAllowThreads(__tstate);
16371 if (PyErr_Occurred()) SWIG_fail;
16372 }
16373 resultobj = SWIG_Py_Void();
16374 {
16375 if (temp2)
16376 delete arg2;
16377 }
16378 return resultobj;
16379 fail:
16380 {
16381 if (temp2)
16382 delete arg2;
16383 }
16384 return NULL;
16385 }
16386
16387
16388 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16389 PyObject *resultobj = 0;
16390 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16391 wxString *arg2 = 0 ;
16392 void *argp1 = 0 ;
16393 int res1 = 0 ;
16394 bool temp2 = false ;
16395 PyObject * obj0 = 0 ;
16396 PyObject * obj1 = 0 ;
16397 char * kwnames[] = {
16398 (char *) "self",(char *) "shortDesc", NULL
16399 };
16400
16401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16403 if (!SWIG_IsOK(res1)) {
16404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16405 }
16406 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16407 {
16408 arg2 = wxString_in_helper(obj1);
16409 if (arg2 == NULL) SWIG_fail;
16410 temp2 = true;
16411 }
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 (arg1)->SetShortDesc((wxString const &)*arg2);
16415 wxPyEndAllowThreads(__tstate);
16416 if (PyErr_Occurred()) SWIG_fail;
16417 }
16418 resultobj = SWIG_Py_Void();
16419 {
16420 if (temp2)
16421 delete arg2;
16422 }
16423 return resultobj;
16424 fail:
16425 {
16426 if (temp2)
16427 delete arg2;
16428 }
16429 return NULL;
16430 }
16431
16432
16433 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16434 PyObject *resultobj = 0;
16435 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16436 wxString *result = 0 ;
16437 void *argp1 = 0 ;
16438 int res1 = 0 ;
16439 PyObject *swig_obj[1] ;
16440
16441 if (!args) SWIG_fail;
16442 swig_obj[0] = args;
16443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16444 if (!SWIG_IsOK(res1)) {
16445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16446 }
16447 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16448 {
16449 PyThreadState* __tstate = wxPyBeginAllowThreads();
16450 {
16451 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16452 result = (wxString *) &_result_ref;
16453 }
16454 wxPyEndAllowThreads(__tstate);
16455 if (PyErr_Occurred()) SWIG_fail;
16456 }
16457 {
16458 #if wxUSE_UNICODE
16459 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16460 #else
16461 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16462 #endif
16463 }
16464 return resultobj;
16465 fail:
16466 return NULL;
16467 }
16468
16469
16470 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16471 PyObject *resultobj = 0;
16472 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16473 wxString *result = 0 ;
16474 void *argp1 = 0 ;
16475 int res1 = 0 ;
16476 PyObject *swig_obj[1] ;
16477
16478 if (!args) SWIG_fail;
16479 swig_obj[0] = args;
16480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16481 if (!SWIG_IsOK(res1)) {
16482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16483 }
16484 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16485 {
16486 PyThreadState* __tstate = wxPyBeginAllowThreads();
16487 {
16488 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16489 result = (wxString *) &_result_ref;
16490 }
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 {
16495 #if wxUSE_UNICODE
16496 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16497 #else
16498 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16499 #endif
16500 }
16501 return resultobj;
16502 fail:
16503 return NULL;
16504 }
16505
16506
16507 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16508 PyObject *resultobj = 0;
16509 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16510 wxString *result = 0 ;
16511 void *argp1 = 0 ;
16512 int res1 = 0 ;
16513 PyObject *swig_obj[1] ;
16514
16515 if (!args) SWIG_fail;
16516 swig_obj[0] = args;
16517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16518 if (!SWIG_IsOK(res1)) {
16519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16520 }
16521 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16522 {
16523 PyThreadState* __tstate = wxPyBeginAllowThreads();
16524 {
16525 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16526 result = (wxString *) &_result_ref;
16527 }
16528 wxPyEndAllowThreads(__tstate);
16529 if (PyErr_Occurred()) SWIG_fail;
16530 }
16531 {
16532 #if wxUSE_UNICODE
16533 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16534 #else
16535 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16536 #endif
16537 }
16538 return resultobj;
16539 fail:
16540 return NULL;
16541 }
16542
16543
16544 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16545 PyObject *resultobj = 0;
16546 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16547 wxString *result = 0 ;
16548 void *argp1 = 0 ;
16549 int res1 = 0 ;
16550 PyObject *swig_obj[1] ;
16551
16552 if (!args) SWIG_fail;
16553 swig_obj[0] = args;
16554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16555 if (!SWIG_IsOK(res1)) {
16556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16557 }
16558 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16559 {
16560 PyThreadState* __tstate = wxPyBeginAllowThreads();
16561 {
16562 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16563 result = (wxString *) &_result_ref;
16564 }
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 {
16569 #if wxUSE_UNICODE
16570 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16571 #else
16572 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16573 #endif
16574 }
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16582 PyObject *resultobj = 0;
16583 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16584 wxString *result = 0 ;
16585 void *argp1 = 0 ;
16586 int res1 = 0 ;
16587 PyObject *swig_obj[1] ;
16588
16589 if (!args) SWIG_fail;
16590 swig_obj[0] = args;
16591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16592 if (!SWIG_IsOK(res1)) {
16593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16594 }
16595 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 {
16599 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16600 result = (wxString *) &_result_ref;
16601 }
16602 wxPyEndAllowThreads(__tstate);
16603 if (PyErr_Occurred()) SWIG_fail;
16604 }
16605 {
16606 #if wxUSE_UNICODE
16607 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16608 #else
16609 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16610 #endif
16611 }
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16619 PyObject *resultobj = 0;
16620 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16621 wxArrayString *result = 0 ;
16622 void *argp1 = 0 ;
16623 int res1 = 0 ;
16624 PyObject *swig_obj[1] ;
16625
16626 if (!args) SWIG_fail;
16627 swig_obj[0] = args;
16628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16629 if (!SWIG_IsOK(res1)) {
16630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16631 }
16632 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16633 {
16634 PyThreadState* __tstate = wxPyBeginAllowThreads();
16635 {
16636 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16637 result = (wxArrayString *) &_result_ref;
16638 }
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 {
16643 resultobj = wxArrayString2PyList_helper(*result);
16644 }
16645 return resultobj;
16646 fail:
16647 return NULL;
16648 }
16649
16650
16651 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16652 PyObject *resultobj = 0;
16653 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16654 size_t result;
16655 void *argp1 = 0 ;
16656 int res1 = 0 ;
16657 PyObject *swig_obj[1] ;
16658
16659 if (!args) SWIG_fail;
16660 swig_obj[0] = args;
16661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16662 if (!SWIG_IsOK(res1)) {
16663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16664 }
16665 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16666 {
16667 PyThreadState* __tstate = wxPyBeginAllowThreads();
16668 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16669 wxPyEndAllowThreads(__tstate);
16670 if (PyErr_Occurred()) SWIG_fail;
16671 }
16672 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16673 return resultobj;
16674 fail:
16675 return NULL;
16676 }
16677
16678
16679 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16680 PyObject *resultobj = 0;
16681 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16682 wxString *result = 0 ;
16683 void *argp1 = 0 ;
16684 int res1 = 0 ;
16685 PyObject *swig_obj[1] ;
16686
16687 if (!args) SWIG_fail;
16688 swig_obj[0] = args;
16689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16690 if (!SWIG_IsOK(res1)) {
16691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16692 }
16693 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16694 {
16695 PyThreadState* __tstate = wxPyBeginAllowThreads();
16696 {
16697 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16698 result = (wxString *) &_result_ref;
16699 }
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 {
16704 #if wxUSE_UNICODE
16705 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16706 #else
16707 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16708 #endif
16709 }
16710 return resultobj;
16711 fail:
16712 return NULL;
16713 }
16714
16715
16716 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16717 PyObject *resultobj = 0;
16718 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16719 int result;
16720 void *argp1 = 0 ;
16721 int res1 = 0 ;
16722 PyObject *swig_obj[1] ;
16723
16724 if (!args) SWIG_fail;
16725 swig_obj[0] = args;
16726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16727 if (!SWIG_IsOK(res1)) {
16728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16729 }
16730 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16731 {
16732 PyThreadState* __tstate = wxPyBeginAllowThreads();
16733 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16734 wxPyEndAllowThreads(__tstate);
16735 if (PyErr_Occurred()) SWIG_fail;
16736 }
16737 resultobj = SWIG_From_int(static_cast< int >(result));
16738 return resultobj;
16739 fail:
16740 return NULL;
16741 }
16742
16743
16744 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16745 PyObject *obj;
16746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16747 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16748 return SWIG_Py_Void();
16749 }
16750
16751 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16752 return SWIG_Python_InitShadowInstance(args);
16753 }
16754
16755 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj = 0;
16757 wxFileTypeInfo *arg1 = 0 ;
16758 wxFileType *result = 0 ;
16759 void *argp1 = 0 ;
16760 int res1 = 0 ;
16761 PyObject * obj0 = 0 ;
16762 char * kwnames[] = {
16763 (char *) "ftInfo", NULL
16764 };
16765
16766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16767 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16768 if (!SWIG_IsOK(res1)) {
16769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16770 }
16771 if (!argp1) {
16772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16773 }
16774 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16775 {
16776 PyThreadState* __tstate = wxPyBeginAllowThreads();
16777 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16782 return resultobj;
16783 fail:
16784 return NULL;
16785 }
16786
16787
16788 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16789 PyObject *resultobj = 0;
16790 wxFileType *arg1 = (wxFileType *) 0 ;
16791 void *argp1 = 0 ;
16792 int res1 = 0 ;
16793 PyObject *swig_obj[1] ;
16794
16795 if (!args) SWIG_fail;
16796 swig_obj[0] = args;
16797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16798 if (!SWIG_IsOK(res1)) {
16799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16800 }
16801 arg1 = reinterpret_cast< wxFileType * >(argp1);
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 delete arg1;
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 resultobj = SWIG_Py_Void();
16810 return resultobj;
16811 fail:
16812 return NULL;
16813 }
16814
16815
16816 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16817 PyObject *resultobj = 0;
16818 wxFileType *arg1 = (wxFileType *) 0 ;
16819 PyObject *result = 0 ;
16820 void *argp1 = 0 ;
16821 int res1 = 0 ;
16822 PyObject *swig_obj[1] ;
16823
16824 if (!args) SWIG_fail;
16825 swig_obj[0] = args;
16826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16827 if (!SWIG_IsOK(res1)) {
16828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16829 }
16830 arg1 = reinterpret_cast< wxFileType * >(argp1);
16831 {
16832 PyThreadState* __tstate = wxPyBeginAllowThreads();
16833 result = (PyObject *)wxFileType_GetMimeType(arg1);
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 resultobj = result;
16838 return resultobj;
16839 fail:
16840 return NULL;
16841 }
16842
16843
16844 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16845 PyObject *resultobj = 0;
16846 wxFileType *arg1 = (wxFileType *) 0 ;
16847 PyObject *result = 0 ;
16848 void *argp1 = 0 ;
16849 int res1 = 0 ;
16850 PyObject *swig_obj[1] ;
16851
16852 if (!args) SWIG_fail;
16853 swig_obj[0] = args;
16854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16855 if (!SWIG_IsOK(res1)) {
16856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16857 }
16858 arg1 = reinterpret_cast< wxFileType * >(argp1);
16859 {
16860 PyThreadState* __tstate = wxPyBeginAllowThreads();
16861 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16862 wxPyEndAllowThreads(__tstate);
16863 if (PyErr_Occurred()) SWIG_fail;
16864 }
16865 resultobj = result;
16866 return resultobj;
16867 fail:
16868 return NULL;
16869 }
16870
16871
16872 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16873 PyObject *resultobj = 0;
16874 wxFileType *arg1 = (wxFileType *) 0 ;
16875 PyObject *result = 0 ;
16876 void *argp1 = 0 ;
16877 int res1 = 0 ;
16878 PyObject *swig_obj[1] ;
16879
16880 if (!args) SWIG_fail;
16881 swig_obj[0] = args;
16882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16883 if (!SWIG_IsOK(res1)) {
16884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16885 }
16886 arg1 = reinterpret_cast< wxFileType * >(argp1);
16887 {
16888 PyThreadState* __tstate = wxPyBeginAllowThreads();
16889 result = (PyObject *)wxFileType_GetExtensions(arg1);
16890 wxPyEndAllowThreads(__tstate);
16891 if (PyErr_Occurred()) SWIG_fail;
16892 }
16893 resultobj = result;
16894 return resultobj;
16895 fail:
16896 return NULL;
16897 }
16898
16899
16900 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16901 PyObject *resultobj = 0;
16902 wxFileType *arg1 = (wxFileType *) 0 ;
16903 wxIcon *result = 0 ;
16904 void *argp1 = 0 ;
16905 int res1 = 0 ;
16906 PyObject *swig_obj[1] ;
16907
16908 if (!args) SWIG_fail;
16909 swig_obj[0] = args;
16910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16911 if (!SWIG_IsOK(res1)) {
16912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16913 }
16914 arg1 = reinterpret_cast< wxFileType * >(argp1);
16915 {
16916 PyThreadState* __tstate = wxPyBeginAllowThreads();
16917 result = (wxIcon *)wxFileType_GetIcon(arg1);
16918 wxPyEndAllowThreads(__tstate);
16919 if (PyErr_Occurred()) SWIG_fail;
16920 }
16921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16922 return resultobj;
16923 fail:
16924 return NULL;
16925 }
16926
16927
16928 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16929 PyObject *resultobj = 0;
16930 wxFileType *arg1 = (wxFileType *) 0 ;
16931 PyObject *result = 0 ;
16932 void *argp1 = 0 ;
16933 int res1 = 0 ;
16934 PyObject *swig_obj[1] ;
16935
16936 if (!args) SWIG_fail;
16937 swig_obj[0] = args;
16938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16939 if (!SWIG_IsOK(res1)) {
16940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16941 }
16942 arg1 = reinterpret_cast< wxFileType * >(argp1);
16943 {
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 resultobj = result;
16950 return resultobj;
16951 fail:
16952 return NULL;
16953 }
16954
16955
16956 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16957 PyObject *resultobj = 0;
16958 wxFileType *arg1 = (wxFileType *) 0 ;
16959 PyObject *result = 0 ;
16960 void *argp1 = 0 ;
16961 int res1 = 0 ;
16962 PyObject *swig_obj[1] ;
16963
16964 if (!args) SWIG_fail;
16965 swig_obj[0] = args;
16966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16967 if (!SWIG_IsOK(res1)) {
16968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16969 }
16970 arg1 = reinterpret_cast< wxFileType * >(argp1);
16971 {
16972 PyThreadState* __tstate = wxPyBeginAllowThreads();
16973 result = (PyObject *)wxFileType_GetDescription(arg1);
16974 wxPyEndAllowThreads(__tstate);
16975 if (PyErr_Occurred()) SWIG_fail;
16976 }
16977 resultobj = result;
16978 return resultobj;
16979 fail:
16980 return NULL;
16981 }
16982
16983
16984 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16985 PyObject *resultobj = 0;
16986 wxFileType *arg1 = (wxFileType *) 0 ;
16987 wxString *arg2 = 0 ;
16988 wxString const &arg3_defvalue = wxPyEmptyString ;
16989 wxString *arg3 = (wxString *) &arg3_defvalue ;
16990 PyObject *result = 0 ;
16991 void *argp1 = 0 ;
16992 int res1 = 0 ;
16993 bool temp2 = false ;
16994 bool temp3 = false ;
16995 PyObject * obj0 = 0 ;
16996 PyObject * obj1 = 0 ;
16997 PyObject * obj2 = 0 ;
16998 char * kwnames[] = {
16999 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17000 };
17001
17002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17004 if (!SWIG_IsOK(res1)) {
17005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17006 }
17007 arg1 = reinterpret_cast< wxFileType * >(argp1);
17008 {
17009 arg2 = wxString_in_helper(obj1);
17010 if (arg2 == NULL) SWIG_fail;
17011 temp2 = true;
17012 }
17013 if (obj2) {
17014 {
17015 arg3 = wxString_in_helper(obj2);
17016 if (arg3 == NULL) SWIG_fail;
17017 temp3 = true;
17018 }
17019 }
17020 {
17021 PyThreadState* __tstate = wxPyBeginAllowThreads();
17022 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17023 wxPyEndAllowThreads(__tstate);
17024 if (PyErr_Occurred()) SWIG_fail;
17025 }
17026 resultobj = result;
17027 {
17028 if (temp2)
17029 delete arg2;
17030 }
17031 {
17032 if (temp3)
17033 delete arg3;
17034 }
17035 return resultobj;
17036 fail:
17037 {
17038 if (temp2)
17039 delete arg2;
17040 }
17041 {
17042 if (temp3)
17043 delete arg3;
17044 }
17045 return NULL;
17046 }
17047
17048
17049 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17050 PyObject *resultobj = 0;
17051 wxFileType *arg1 = (wxFileType *) 0 ;
17052 wxString *arg2 = 0 ;
17053 wxString const &arg3_defvalue = wxPyEmptyString ;
17054 wxString *arg3 = (wxString *) &arg3_defvalue ;
17055 PyObject *result = 0 ;
17056 void *argp1 = 0 ;
17057 int res1 = 0 ;
17058 bool temp2 = false ;
17059 bool temp3 = false ;
17060 PyObject * obj0 = 0 ;
17061 PyObject * obj1 = 0 ;
17062 PyObject * obj2 = 0 ;
17063 char * kwnames[] = {
17064 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17065 };
17066
17067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17069 if (!SWIG_IsOK(res1)) {
17070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17071 }
17072 arg1 = reinterpret_cast< wxFileType * >(argp1);
17073 {
17074 arg2 = wxString_in_helper(obj1);
17075 if (arg2 == NULL) SWIG_fail;
17076 temp2 = true;
17077 }
17078 if (obj2) {
17079 {
17080 arg3 = wxString_in_helper(obj2);
17081 if (arg3 == NULL) SWIG_fail;
17082 temp3 = true;
17083 }
17084 }
17085 {
17086 PyThreadState* __tstate = wxPyBeginAllowThreads();
17087 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 resultobj = result;
17092 {
17093 if (temp2)
17094 delete arg2;
17095 }
17096 {
17097 if (temp3)
17098 delete arg3;
17099 }
17100 return resultobj;
17101 fail:
17102 {
17103 if (temp2)
17104 delete arg2;
17105 }
17106 {
17107 if (temp3)
17108 delete arg3;
17109 }
17110 return NULL;
17111 }
17112
17113
17114 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj = 0;
17116 wxFileType *arg1 = (wxFileType *) 0 ;
17117 wxString *arg2 = 0 ;
17118 wxString const &arg3_defvalue = wxPyEmptyString ;
17119 wxString *arg3 = (wxString *) &arg3_defvalue ;
17120 PyObject *result = 0 ;
17121 void *argp1 = 0 ;
17122 int res1 = 0 ;
17123 bool temp2 = false ;
17124 bool temp3 = false ;
17125 PyObject * obj0 = 0 ;
17126 PyObject * obj1 = 0 ;
17127 PyObject * obj2 = 0 ;
17128 char * kwnames[] = {
17129 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17130 };
17131
17132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17134 if (!SWIG_IsOK(res1)) {
17135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17136 }
17137 arg1 = reinterpret_cast< wxFileType * >(argp1);
17138 {
17139 arg2 = wxString_in_helper(obj1);
17140 if (arg2 == NULL) SWIG_fail;
17141 temp2 = true;
17142 }
17143 if (obj2) {
17144 {
17145 arg3 = wxString_in_helper(obj2);
17146 if (arg3 == NULL) SWIG_fail;
17147 temp3 = true;
17148 }
17149 }
17150 {
17151 PyThreadState* __tstate = wxPyBeginAllowThreads();
17152 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17153 wxPyEndAllowThreads(__tstate);
17154 if (PyErr_Occurred()) SWIG_fail;
17155 }
17156 resultobj = result;
17157 {
17158 if (temp2)
17159 delete arg2;
17160 }
17161 {
17162 if (temp3)
17163 delete arg3;
17164 }
17165 return resultobj;
17166 fail:
17167 {
17168 if (temp2)
17169 delete arg2;
17170 }
17171 {
17172 if (temp3)
17173 delete arg3;
17174 }
17175 return NULL;
17176 }
17177
17178
17179 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17180 PyObject *resultobj = 0;
17181 wxFileType *arg1 = (wxFileType *) 0 ;
17182 wxString *arg2 = 0 ;
17183 wxString *arg3 = 0 ;
17184 bool arg4 = (bool) true ;
17185 bool result;
17186 void *argp1 = 0 ;
17187 int res1 = 0 ;
17188 bool temp2 = false ;
17189 bool temp3 = false ;
17190 bool val4 ;
17191 int ecode4 = 0 ;
17192 PyObject * obj0 = 0 ;
17193 PyObject * obj1 = 0 ;
17194 PyObject * obj2 = 0 ;
17195 PyObject * obj3 = 0 ;
17196 char * kwnames[] = {
17197 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17198 };
17199
17200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17202 if (!SWIG_IsOK(res1)) {
17203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17204 }
17205 arg1 = reinterpret_cast< wxFileType * >(argp1);
17206 {
17207 arg2 = wxString_in_helper(obj1);
17208 if (arg2 == NULL) SWIG_fail;
17209 temp2 = true;
17210 }
17211 {
17212 arg3 = wxString_in_helper(obj2);
17213 if (arg3 == NULL) SWIG_fail;
17214 temp3 = true;
17215 }
17216 if (obj3) {
17217 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17218 if (!SWIG_IsOK(ecode4)) {
17219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17220 }
17221 arg4 = static_cast< bool >(val4);
17222 }
17223 {
17224 PyThreadState* __tstate = wxPyBeginAllowThreads();
17225 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 {
17230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17231 }
17232 {
17233 if (temp2)
17234 delete arg2;
17235 }
17236 {
17237 if (temp3)
17238 delete arg3;
17239 }
17240 return resultobj;
17241 fail:
17242 {
17243 if (temp2)
17244 delete arg2;
17245 }
17246 {
17247 if (temp3)
17248 delete arg3;
17249 }
17250 return NULL;
17251 }
17252
17253
17254 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj = 0;
17256 wxFileType *arg1 = (wxFileType *) 0 ;
17257 wxString const &arg2_defvalue = wxPyEmptyString ;
17258 wxString *arg2 = (wxString *) &arg2_defvalue ;
17259 int arg3 = (int) 0 ;
17260 bool result;
17261 void *argp1 = 0 ;
17262 int res1 = 0 ;
17263 bool temp2 = false ;
17264 int val3 ;
17265 int ecode3 = 0 ;
17266 PyObject * obj0 = 0 ;
17267 PyObject * obj1 = 0 ;
17268 PyObject * obj2 = 0 ;
17269 char * kwnames[] = {
17270 (char *) "self",(char *) "cmd",(char *) "index", NULL
17271 };
17272
17273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17275 if (!SWIG_IsOK(res1)) {
17276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17277 }
17278 arg1 = reinterpret_cast< wxFileType * >(argp1);
17279 if (obj1) {
17280 {
17281 arg2 = wxString_in_helper(obj1);
17282 if (arg2 == NULL) SWIG_fail;
17283 temp2 = true;
17284 }
17285 }
17286 if (obj2) {
17287 ecode3 = SWIG_AsVal_int(obj2, &val3);
17288 if (!SWIG_IsOK(ecode3)) {
17289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17290 }
17291 arg3 = static_cast< int >(val3);
17292 }
17293 {
17294 PyThreadState* __tstate = wxPyBeginAllowThreads();
17295 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17296 wxPyEndAllowThreads(__tstate);
17297 if (PyErr_Occurred()) SWIG_fail;
17298 }
17299 {
17300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17301 }
17302 {
17303 if (temp2)
17304 delete arg2;
17305 }
17306 return resultobj;
17307 fail:
17308 {
17309 if (temp2)
17310 delete arg2;
17311 }
17312 return NULL;
17313 }
17314
17315
17316 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17317 PyObject *resultobj = 0;
17318 wxFileType *arg1 = (wxFileType *) 0 ;
17319 bool result;
17320 void *argp1 = 0 ;
17321 int res1 = 0 ;
17322 PyObject *swig_obj[1] ;
17323
17324 if (!args) SWIG_fail;
17325 swig_obj[0] = args;
17326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17327 if (!SWIG_IsOK(res1)) {
17328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17329 }
17330 arg1 = reinterpret_cast< wxFileType * >(argp1);
17331 {
17332 PyThreadState* __tstate = wxPyBeginAllowThreads();
17333 result = (bool)(arg1)->Unassociate();
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 {
17338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17339 }
17340 return resultobj;
17341 fail:
17342 return NULL;
17343 }
17344
17345
17346 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17347 PyObject *resultobj = 0;
17348 wxString *arg1 = 0 ;
17349 wxString *arg2 = 0 ;
17350 wxString const &arg3_defvalue = wxPyEmptyString ;
17351 wxString *arg3 = (wxString *) &arg3_defvalue ;
17352 wxString result;
17353 bool temp1 = false ;
17354 bool temp2 = false ;
17355 bool temp3 = false ;
17356 PyObject * obj0 = 0 ;
17357 PyObject * obj1 = 0 ;
17358 PyObject * obj2 = 0 ;
17359 char * kwnames[] = {
17360 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17361 };
17362
17363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17364 {
17365 arg1 = wxString_in_helper(obj0);
17366 if (arg1 == NULL) SWIG_fail;
17367 temp1 = true;
17368 }
17369 {
17370 arg2 = wxString_in_helper(obj1);
17371 if (arg2 == NULL) SWIG_fail;
17372 temp2 = true;
17373 }
17374 if (obj2) {
17375 {
17376 arg3 = wxString_in_helper(obj2);
17377 if (arg3 == NULL) SWIG_fail;
17378 temp3 = true;
17379 }
17380 }
17381 {
17382 PyThreadState* __tstate = wxPyBeginAllowThreads();
17383 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17384 wxPyEndAllowThreads(__tstate);
17385 if (PyErr_Occurred()) SWIG_fail;
17386 }
17387 {
17388 #if wxUSE_UNICODE
17389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17390 #else
17391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17392 #endif
17393 }
17394 {
17395 if (temp1)
17396 delete arg1;
17397 }
17398 {
17399 if (temp2)
17400 delete arg2;
17401 }
17402 {
17403 if (temp3)
17404 delete arg3;
17405 }
17406 return resultobj;
17407 fail:
17408 {
17409 if (temp1)
17410 delete arg1;
17411 }
17412 {
17413 if (temp2)
17414 delete arg2;
17415 }
17416 {
17417 if (temp3)
17418 delete arg3;
17419 }
17420 return NULL;
17421 }
17422
17423
17424 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17425 PyObject *obj;
17426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17427 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17428 return SWIG_Py_Void();
17429 }
17430
17431 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17432 return SWIG_Python_InitShadowInstance(args);
17433 }
17434
17435 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17436 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17437 return 1;
17438 }
17439
17440
17441 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17442 PyObject *pyobj = 0;
17443
17444 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17445 return pyobj;
17446 }
17447
17448
17449 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17450 PyObject *resultobj = 0;
17451 wxString *arg1 = 0 ;
17452 wxString *arg2 = 0 ;
17453 bool result;
17454 bool temp1 = false ;
17455 bool temp2 = false ;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 char * kwnames[] = {
17459 (char *) "mimeType",(char *) "wildcard", NULL
17460 };
17461
17462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17463 {
17464 arg1 = wxString_in_helper(obj0);
17465 if (arg1 == NULL) SWIG_fail;
17466 temp1 = true;
17467 }
17468 {
17469 arg2 = wxString_in_helper(obj1);
17470 if (arg2 == NULL) SWIG_fail;
17471 temp2 = true;
17472 }
17473 {
17474 PyThreadState* __tstate = wxPyBeginAllowThreads();
17475 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 {
17480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17481 }
17482 {
17483 if (temp1)
17484 delete arg1;
17485 }
17486 {
17487 if (temp2)
17488 delete arg2;
17489 }
17490 return resultobj;
17491 fail:
17492 {
17493 if (temp1)
17494 delete arg1;
17495 }
17496 {
17497 if (temp2)
17498 delete arg2;
17499 }
17500 return NULL;
17501 }
17502
17503
17504 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17505 PyObject *resultobj = 0;
17506 wxMimeTypesManager *result = 0 ;
17507
17508 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17523 PyObject *resultobj = 0;
17524 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17525 int arg2 = (int) wxMAILCAP_ALL ;
17526 wxString const &arg3_defvalue = wxPyEmptyString ;
17527 wxString *arg3 = (wxString *) &arg3_defvalue ;
17528 void *argp1 = 0 ;
17529 int res1 = 0 ;
17530 int val2 ;
17531 int ecode2 = 0 ;
17532 bool temp3 = false ;
17533 PyObject * obj0 = 0 ;
17534 PyObject * obj1 = 0 ;
17535 PyObject * obj2 = 0 ;
17536 char * kwnames[] = {
17537 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17538 };
17539
17540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17542 if (!SWIG_IsOK(res1)) {
17543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17544 }
17545 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17546 if (obj1) {
17547 ecode2 = SWIG_AsVal_int(obj1, &val2);
17548 if (!SWIG_IsOK(ecode2)) {
17549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17550 }
17551 arg2 = static_cast< int >(val2);
17552 }
17553 if (obj2) {
17554 {
17555 arg3 = wxString_in_helper(obj2);
17556 if (arg3 == NULL) SWIG_fail;
17557 temp3 = true;
17558 }
17559 }
17560 {
17561 PyThreadState* __tstate = wxPyBeginAllowThreads();
17562 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17563 wxPyEndAllowThreads(__tstate);
17564 if (PyErr_Occurred()) SWIG_fail;
17565 }
17566 resultobj = SWIG_Py_Void();
17567 {
17568 if (temp3)
17569 delete arg3;
17570 }
17571 return resultobj;
17572 fail:
17573 {
17574 if (temp3)
17575 delete arg3;
17576 }
17577 return NULL;
17578 }
17579
17580
17581 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17582 PyObject *resultobj = 0;
17583 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17584 void *argp1 = 0 ;
17585 int res1 = 0 ;
17586 PyObject *swig_obj[1] ;
17587
17588 if (!args) SWIG_fail;
17589 swig_obj[0] = args;
17590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17591 if (!SWIG_IsOK(res1)) {
17592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17593 }
17594 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17595 {
17596 PyThreadState* __tstate = wxPyBeginAllowThreads();
17597 (arg1)->ClearData();
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 resultobj = SWIG_Py_Void();
17602 return resultobj;
17603 fail:
17604 return NULL;
17605 }
17606
17607
17608 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17609 PyObject *resultobj = 0;
17610 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17611 wxString *arg2 = 0 ;
17612 wxFileType *result = 0 ;
17613 void *argp1 = 0 ;
17614 int res1 = 0 ;
17615 bool temp2 = false ;
17616 PyObject * obj0 = 0 ;
17617 PyObject * obj1 = 0 ;
17618 char * kwnames[] = {
17619 (char *) "self",(char *) "ext", NULL
17620 };
17621
17622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17624 if (!SWIG_IsOK(res1)) {
17625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17626 }
17627 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17628 {
17629 arg2 = wxString_in_helper(obj1);
17630 if (arg2 == NULL) SWIG_fail;
17631 temp2 = true;
17632 }
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17636 wxPyEndAllowThreads(__tstate);
17637 if (PyErr_Occurred()) SWIG_fail;
17638 }
17639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17640 {
17641 if (temp2)
17642 delete arg2;
17643 }
17644 return resultobj;
17645 fail:
17646 {
17647 if (temp2)
17648 delete arg2;
17649 }
17650 return NULL;
17651 }
17652
17653
17654 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17655 PyObject *resultobj = 0;
17656 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17657 wxString *arg2 = 0 ;
17658 wxFileType *result = 0 ;
17659 void *argp1 = 0 ;
17660 int res1 = 0 ;
17661 bool temp2 = false ;
17662 PyObject * obj0 = 0 ;
17663 PyObject * obj1 = 0 ;
17664 char * kwnames[] = {
17665 (char *) "self",(char *) "mimeType", NULL
17666 };
17667
17668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17670 if (!SWIG_IsOK(res1)) {
17671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17672 }
17673 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17674 {
17675 arg2 = wxString_in_helper(obj1);
17676 if (arg2 == NULL) SWIG_fail;
17677 temp2 = true;
17678 }
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17686 {
17687 if (temp2)
17688 delete arg2;
17689 }
17690 return resultobj;
17691 fail:
17692 {
17693 if (temp2)
17694 delete arg2;
17695 }
17696 return NULL;
17697 }
17698
17699
17700 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17701 PyObject *resultobj = 0;
17702 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17703 wxString *arg2 = 0 ;
17704 bool arg3 = (bool) false ;
17705 bool result;
17706 void *argp1 = 0 ;
17707 int res1 = 0 ;
17708 bool temp2 = false ;
17709 bool val3 ;
17710 int ecode3 = 0 ;
17711 PyObject * obj0 = 0 ;
17712 PyObject * obj1 = 0 ;
17713 PyObject * obj2 = 0 ;
17714 char * kwnames[] = {
17715 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17716 };
17717
17718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17720 if (!SWIG_IsOK(res1)) {
17721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17722 }
17723 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17724 {
17725 arg2 = wxString_in_helper(obj1);
17726 if (arg2 == NULL) SWIG_fail;
17727 temp2 = true;
17728 }
17729 if (obj2) {
17730 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17731 if (!SWIG_IsOK(ecode3)) {
17732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17733 }
17734 arg3 = static_cast< bool >(val3);
17735 }
17736 {
17737 PyThreadState* __tstate = wxPyBeginAllowThreads();
17738 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17744 }
17745 {
17746 if (temp2)
17747 delete arg2;
17748 }
17749 return resultobj;
17750 fail:
17751 {
17752 if (temp2)
17753 delete arg2;
17754 }
17755 return NULL;
17756 }
17757
17758
17759 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj = 0;
17761 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17762 wxString *arg2 = 0 ;
17763 bool result;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 bool temp2 = false ;
17767 PyObject * obj0 = 0 ;
17768 PyObject * obj1 = 0 ;
17769 char * kwnames[] = {
17770 (char *) "self",(char *) "filename", NULL
17771 };
17772
17773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17775 if (!SWIG_IsOK(res1)) {
17776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17777 }
17778 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17779 {
17780 arg2 = wxString_in_helper(obj1);
17781 if (arg2 == NULL) SWIG_fail;
17782 temp2 = true;
17783 }
17784 {
17785 PyThreadState* __tstate = wxPyBeginAllowThreads();
17786 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17787 wxPyEndAllowThreads(__tstate);
17788 if (PyErr_Occurred()) SWIG_fail;
17789 }
17790 {
17791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17792 }
17793 {
17794 if (temp2)
17795 delete arg2;
17796 }
17797 return resultobj;
17798 fail:
17799 {
17800 if (temp2)
17801 delete arg2;
17802 }
17803 return NULL;
17804 }
17805
17806
17807 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17808 PyObject *resultobj = 0;
17809 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17810 PyObject *result = 0 ;
17811 void *argp1 = 0 ;
17812 int res1 = 0 ;
17813 PyObject *swig_obj[1] ;
17814
17815 if (!args) SWIG_fail;
17816 swig_obj[0] = args;
17817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17818 if (!SWIG_IsOK(res1)) {
17819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17820 }
17821 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17822 {
17823 PyThreadState* __tstate = wxPyBeginAllowThreads();
17824 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17825 wxPyEndAllowThreads(__tstate);
17826 if (PyErr_Occurred()) SWIG_fail;
17827 }
17828 resultobj = result;
17829 return resultobj;
17830 fail:
17831 return NULL;
17832 }
17833
17834
17835 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj = 0;
17837 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17838 wxFileTypeInfo *arg2 = 0 ;
17839 void *argp1 = 0 ;
17840 int res1 = 0 ;
17841 void *argp2 = 0 ;
17842 int res2 = 0 ;
17843 PyObject * obj0 = 0 ;
17844 PyObject * obj1 = 0 ;
17845 char * kwnames[] = {
17846 (char *) "self",(char *) "ft", NULL
17847 };
17848
17849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17851 if (!SWIG_IsOK(res1)) {
17852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17853 }
17854 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17855 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17856 if (!SWIG_IsOK(res2)) {
17857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17858 }
17859 if (!argp2) {
17860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17861 }
17862 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 resultobj = SWIG_Py_Void();
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17877 PyObject *resultobj = 0;
17878 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17879 wxFileTypeInfo *arg2 = 0 ;
17880 wxFileType *result = 0 ;
17881 void *argp1 = 0 ;
17882 int res1 = 0 ;
17883 void *argp2 = 0 ;
17884 int res2 = 0 ;
17885 PyObject * obj0 = 0 ;
17886 PyObject * obj1 = 0 ;
17887 char * kwnames[] = {
17888 (char *) "self",(char *) "ftInfo", NULL
17889 };
17890
17891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17893 if (!SWIG_IsOK(res1)) {
17894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17895 }
17896 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17898 if (!SWIG_IsOK(res2)) {
17899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17900 }
17901 if (!argp2) {
17902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17903 }
17904 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17905 {
17906 PyThreadState* __tstate = wxPyBeginAllowThreads();
17907 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17908 wxPyEndAllowThreads(__tstate);
17909 if (PyErr_Occurred()) SWIG_fail;
17910 }
17911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17919 PyObject *resultobj = 0;
17920 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17921 wxFileType *arg2 = (wxFileType *) 0 ;
17922 bool result;
17923 void *argp1 = 0 ;
17924 int res1 = 0 ;
17925 void *argp2 = 0 ;
17926 int res2 = 0 ;
17927 PyObject * obj0 = 0 ;
17928 PyObject * obj1 = 0 ;
17929 char * kwnames[] = {
17930 (char *) "self",(char *) "ft", NULL
17931 };
17932
17933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17935 if (!SWIG_IsOK(res1)) {
17936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17937 }
17938 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17940 if (!SWIG_IsOK(res2)) {
17941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17942 }
17943 arg2 = reinterpret_cast< wxFileType * >(argp2);
17944 {
17945 PyThreadState* __tstate = wxPyBeginAllowThreads();
17946 result = (bool)(arg1)->Unassociate(arg2);
17947 wxPyEndAllowThreads(__tstate);
17948 if (PyErr_Occurred()) SWIG_fail;
17949 }
17950 {
17951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17952 }
17953 return resultobj;
17954 fail:
17955 return NULL;
17956 }
17957
17958
17959 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17960 PyObject *resultobj = 0;
17961 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17962 void *argp1 = 0 ;
17963 int res1 = 0 ;
17964 PyObject *swig_obj[1] ;
17965
17966 if (!args) SWIG_fail;
17967 swig_obj[0] = args;
17968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17969 if (!SWIG_IsOK(res1)) {
17970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17971 }
17972 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17973 {
17974 PyThreadState* __tstate = wxPyBeginAllowThreads();
17975 delete arg1;
17976
17977 wxPyEndAllowThreads(__tstate);
17978 if (PyErr_Occurred()) SWIG_fail;
17979 }
17980 resultobj = SWIG_Py_Void();
17981 return resultobj;
17982 fail:
17983 return NULL;
17984 }
17985
17986
17987 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17988 PyObject *obj;
17989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17990 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
17991 return SWIG_Py_Void();
17992 }
17993
17994 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 return SWIG_Python_InitShadowInstance(args);
17996 }
17997
17998 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
17999 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18000 return 1;
18001 }
18002
18003
18004 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18005 PyObject *pyobj = 0;
18006
18007 {
18008 #if wxUSE_UNICODE
18009 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18010 #else
18011 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18012 #endif
18013 }
18014 return pyobj;
18015 }
18016
18017
18018 SWIGINTERN int ART_MENU_set(PyObject *) {
18019 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18020 return 1;
18021 }
18022
18023
18024 SWIGINTERN PyObject *ART_MENU_get(void) {
18025 PyObject *pyobj = 0;
18026
18027 {
18028 #if wxUSE_UNICODE
18029 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18030 #else
18031 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18032 #endif
18033 }
18034 return pyobj;
18035 }
18036
18037
18038 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18039 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18040 return 1;
18041 }
18042
18043
18044 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18045 PyObject *pyobj = 0;
18046
18047 {
18048 #if wxUSE_UNICODE
18049 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18050 #else
18051 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18052 #endif
18053 }
18054 return pyobj;
18055 }
18056
18057
18058 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18059 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18060 return 1;
18061 }
18062
18063
18064 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18065 PyObject *pyobj = 0;
18066
18067 {
18068 #if wxUSE_UNICODE
18069 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18070 #else
18071 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18072 #endif
18073 }
18074 return pyobj;
18075 }
18076
18077
18078 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18079 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18080 return 1;
18081 }
18082
18083
18084 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18085 PyObject *pyobj = 0;
18086
18087 {
18088 #if wxUSE_UNICODE
18089 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18090 #else
18091 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18092 #endif
18093 }
18094 return pyobj;
18095 }
18096
18097
18098 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18099 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18100 return 1;
18101 }
18102
18103
18104 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18105 PyObject *pyobj = 0;
18106
18107 {
18108 #if wxUSE_UNICODE
18109 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18110 #else
18111 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18112 #endif
18113 }
18114 return pyobj;
18115 }
18116
18117
18118 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18119 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18120 return 1;
18121 }
18122
18123
18124 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18125 PyObject *pyobj = 0;
18126
18127 {
18128 #if wxUSE_UNICODE
18129 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18130 #else
18131 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18132 #endif
18133 }
18134 return pyobj;
18135 }
18136
18137
18138 SWIGINTERN int ART_OTHER_set(PyObject *) {
18139 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18140 return 1;
18141 }
18142
18143
18144 SWIGINTERN PyObject *ART_OTHER_get(void) {
18145 PyObject *pyobj = 0;
18146
18147 {
18148 #if wxUSE_UNICODE
18149 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18150 #else
18151 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18152 #endif
18153 }
18154 return pyobj;
18155 }
18156
18157
18158 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18159 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18160 return 1;
18161 }
18162
18163
18164 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18165 PyObject *pyobj = 0;
18166
18167 {
18168 #if wxUSE_UNICODE
18169 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18170 #else
18171 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18172 #endif
18173 }
18174 return pyobj;
18175 }
18176
18177
18178 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18179 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18180 return 1;
18181 }
18182
18183
18184 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18185 PyObject *pyobj = 0;
18186
18187 {
18188 #if wxUSE_UNICODE
18189 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18190 #else
18191 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18192 #endif
18193 }
18194 return pyobj;
18195 }
18196
18197
18198 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18199 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18200 return 1;
18201 }
18202
18203
18204 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18205 PyObject *pyobj = 0;
18206
18207 {
18208 #if wxUSE_UNICODE
18209 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18210 #else
18211 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18212 #endif
18213 }
18214 return pyobj;
18215 }
18216
18217
18218 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18219 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18220 return 1;
18221 }
18222
18223
18224 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18225 PyObject *pyobj = 0;
18226
18227 {
18228 #if wxUSE_UNICODE
18229 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18230 #else
18231 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18232 #endif
18233 }
18234 return pyobj;
18235 }
18236
18237
18238 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18239 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18240 return 1;
18241 }
18242
18243
18244 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18245 PyObject *pyobj = 0;
18246
18247 {
18248 #if wxUSE_UNICODE
18249 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18250 #else
18251 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18252 #endif
18253 }
18254 return pyobj;
18255 }
18256
18257
18258 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18259 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18260 return 1;
18261 }
18262
18263
18264 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18265 PyObject *pyobj = 0;
18266
18267 {
18268 #if wxUSE_UNICODE
18269 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18270 #else
18271 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18272 #endif
18273 }
18274 return pyobj;
18275 }
18276
18277
18278 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18279 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18280 return 1;
18281 }
18282
18283
18284 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18285 PyObject *pyobj = 0;
18286
18287 {
18288 #if wxUSE_UNICODE
18289 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18290 #else
18291 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18292 #endif
18293 }
18294 return pyobj;
18295 }
18296
18297
18298 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18299 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18300 return 1;
18301 }
18302
18303
18304 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18305 PyObject *pyobj = 0;
18306
18307 {
18308 #if wxUSE_UNICODE
18309 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18310 #else
18311 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18312 #endif
18313 }
18314 return pyobj;
18315 }
18316
18317
18318 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18319 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18320 return 1;
18321 }
18322
18323
18324 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18325 PyObject *pyobj = 0;
18326
18327 {
18328 #if wxUSE_UNICODE
18329 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18330 #else
18331 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18332 #endif
18333 }
18334 return pyobj;
18335 }
18336
18337
18338 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18339 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18340 return 1;
18341 }
18342
18343
18344 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18345 PyObject *pyobj = 0;
18346
18347 {
18348 #if wxUSE_UNICODE
18349 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18350 #else
18351 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18352 #endif
18353 }
18354 return pyobj;
18355 }
18356
18357
18358 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18359 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18360 return 1;
18361 }
18362
18363
18364 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18365 PyObject *pyobj = 0;
18366
18367 {
18368 #if wxUSE_UNICODE
18369 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18370 #else
18371 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18372 #endif
18373 }
18374 return pyobj;
18375 }
18376
18377
18378 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18379 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18380 return 1;
18381 }
18382
18383
18384 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18385 PyObject *pyobj = 0;
18386
18387 {
18388 #if wxUSE_UNICODE
18389 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18390 #else
18391 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18392 #endif
18393 }
18394 return pyobj;
18395 }
18396
18397
18398 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18399 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18400 return 1;
18401 }
18402
18403
18404 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18405 PyObject *pyobj = 0;
18406
18407 {
18408 #if wxUSE_UNICODE
18409 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18410 #else
18411 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18412 #endif
18413 }
18414 return pyobj;
18415 }
18416
18417
18418 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18419 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18420 return 1;
18421 }
18422
18423
18424 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18425 PyObject *pyobj = 0;
18426
18427 {
18428 #if wxUSE_UNICODE
18429 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18430 #else
18431 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18432 #endif
18433 }
18434 return pyobj;
18435 }
18436
18437
18438 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18439 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18440 return 1;
18441 }
18442
18443
18444 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18445 PyObject *pyobj = 0;
18446
18447 {
18448 #if wxUSE_UNICODE
18449 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18450 #else
18451 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18452 #endif
18453 }
18454 return pyobj;
18455 }
18456
18457
18458 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18459 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18460 return 1;
18461 }
18462
18463
18464 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18465 PyObject *pyobj = 0;
18466
18467 {
18468 #if wxUSE_UNICODE
18469 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18470 #else
18471 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18472 #endif
18473 }
18474 return pyobj;
18475 }
18476
18477
18478 SWIGINTERN int ART_PRINT_set(PyObject *) {
18479 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18480 return 1;
18481 }
18482
18483
18484 SWIGINTERN PyObject *ART_PRINT_get(void) {
18485 PyObject *pyobj = 0;
18486
18487 {
18488 #if wxUSE_UNICODE
18489 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18490 #else
18491 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18492 #endif
18493 }
18494 return pyobj;
18495 }
18496
18497
18498 SWIGINTERN int ART_HELP_set(PyObject *) {
18499 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18500 return 1;
18501 }
18502
18503
18504 SWIGINTERN PyObject *ART_HELP_get(void) {
18505 PyObject *pyobj = 0;
18506
18507 {
18508 #if wxUSE_UNICODE
18509 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18510 #else
18511 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18512 #endif
18513 }
18514 return pyobj;
18515 }
18516
18517
18518 SWIGINTERN int ART_TIP_set(PyObject *) {
18519 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18520 return 1;
18521 }
18522
18523
18524 SWIGINTERN PyObject *ART_TIP_get(void) {
18525 PyObject *pyobj = 0;
18526
18527 {
18528 #if wxUSE_UNICODE
18529 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18530 #else
18531 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18532 #endif
18533 }
18534 return pyobj;
18535 }
18536
18537
18538 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18539 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18540 return 1;
18541 }
18542
18543
18544 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18545 PyObject *pyobj = 0;
18546
18547 {
18548 #if wxUSE_UNICODE
18549 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18550 #else
18551 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18552 #endif
18553 }
18554 return pyobj;
18555 }
18556
18557
18558 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18559 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18560 return 1;
18561 }
18562
18563
18564 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18565 PyObject *pyobj = 0;
18566
18567 {
18568 #if wxUSE_UNICODE
18569 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18570 #else
18571 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18572 #endif
18573 }
18574 return pyobj;
18575 }
18576
18577
18578 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18579 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18580 return 1;
18581 }
18582
18583
18584 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18585 PyObject *pyobj = 0;
18586
18587 {
18588 #if wxUSE_UNICODE
18589 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18590 #else
18591 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18592 #endif
18593 }
18594 return pyobj;
18595 }
18596
18597
18598 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18599 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18600 return 1;
18601 }
18602
18603
18604 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18605 PyObject *pyobj = 0;
18606
18607 {
18608 #if wxUSE_UNICODE
18609 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18610 #else
18611 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18612 #endif
18613 }
18614 return pyobj;
18615 }
18616
18617
18618 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18619 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18620 return 1;
18621 }
18622
18623
18624 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18625 PyObject *pyobj = 0;
18626
18627 {
18628 #if wxUSE_UNICODE
18629 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18630 #else
18631 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18632 #endif
18633 }
18634 return pyobj;
18635 }
18636
18637
18638 SWIGINTERN int ART_CDROM_set(PyObject *) {
18639 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18640 return 1;
18641 }
18642
18643
18644 SWIGINTERN PyObject *ART_CDROM_get(void) {
18645 PyObject *pyobj = 0;
18646
18647 {
18648 #if wxUSE_UNICODE
18649 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18650 #else
18651 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18652 #endif
18653 }
18654 return pyobj;
18655 }
18656
18657
18658 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18659 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18660 return 1;
18661 }
18662
18663
18664 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18665 PyObject *pyobj = 0;
18666
18667 {
18668 #if wxUSE_UNICODE
18669 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18670 #else
18671 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18672 #endif
18673 }
18674 return pyobj;
18675 }
18676
18677
18678 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18679 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18680 return 1;
18681 }
18682
18683
18684 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18685 PyObject *pyobj = 0;
18686
18687 {
18688 #if wxUSE_UNICODE
18689 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18690 #else
18691 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18692 #endif
18693 }
18694 return pyobj;
18695 }
18696
18697
18698 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18699 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18700 return 1;
18701 }
18702
18703
18704 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18705 PyObject *pyobj = 0;
18706
18707 {
18708 #if wxUSE_UNICODE
18709 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18710 #else
18711 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18712 #endif
18713 }
18714 return pyobj;
18715 }
18716
18717
18718 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18719 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18720 return 1;
18721 }
18722
18723
18724 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18725 PyObject *pyobj = 0;
18726
18727 {
18728 #if wxUSE_UNICODE
18729 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18730 #else
18731 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18732 #endif
18733 }
18734 return pyobj;
18735 }
18736
18737
18738 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18739 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18740 return 1;
18741 }
18742
18743
18744 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18745 PyObject *pyobj = 0;
18746
18747 {
18748 #if wxUSE_UNICODE
18749 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18750 #else
18751 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18752 #endif
18753 }
18754 return pyobj;
18755 }
18756
18757
18758 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18759 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18760 return 1;
18761 }
18762
18763
18764 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18765 PyObject *pyobj = 0;
18766
18767 {
18768 #if wxUSE_UNICODE
18769 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18770 #else
18771 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18772 #endif
18773 }
18774 return pyobj;
18775 }
18776
18777
18778 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18779 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18780 return 1;
18781 }
18782
18783
18784 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18785 PyObject *pyobj = 0;
18786
18787 {
18788 #if wxUSE_UNICODE
18789 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18790 #else
18791 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18792 #endif
18793 }
18794 return pyobj;
18795 }
18796
18797
18798 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18799 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18800 return 1;
18801 }
18802
18803
18804 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18805 PyObject *pyobj = 0;
18806
18807 {
18808 #if wxUSE_UNICODE
18809 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18810 #else
18811 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18812 #endif
18813 }
18814 return pyobj;
18815 }
18816
18817
18818 SWIGINTERN int ART_ERROR_set(PyObject *) {
18819 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18820 return 1;
18821 }
18822
18823
18824 SWIGINTERN PyObject *ART_ERROR_get(void) {
18825 PyObject *pyobj = 0;
18826
18827 {
18828 #if wxUSE_UNICODE
18829 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18830 #else
18831 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18832 #endif
18833 }
18834 return pyobj;
18835 }
18836
18837
18838 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18839 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18840 return 1;
18841 }
18842
18843
18844 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18845 PyObject *pyobj = 0;
18846
18847 {
18848 #if wxUSE_UNICODE
18849 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18850 #else
18851 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18852 #endif
18853 }
18854 return pyobj;
18855 }
18856
18857
18858 SWIGINTERN int ART_WARNING_set(PyObject *) {
18859 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18860 return 1;
18861 }
18862
18863
18864 SWIGINTERN PyObject *ART_WARNING_get(void) {
18865 PyObject *pyobj = 0;
18866
18867 {
18868 #if wxUSE_UNICODE
18869 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18870 #else
18871 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18872 #endif
18873 }
18874 return pyobj;
18875 }
18876
18877
18878 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18879 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18880 return 1;
18881 }
18882
18883
18884 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18885 PyObject *pyobj = 0;
18886
18887 {
18888 #if wxUSE_UNICODE
18889 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18890 #else
18891 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18892 #endif
18893 }
18894 return pyobj;
18895 }
18896
18897
18898 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18899 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18900 return 1;
18901 }
18902
18903
18904 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18905 PyObject *pyobj = 0;
18906
18907 {
18908 #if wxUSE_UNICODE
18909 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18910 #else
18911 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18912 #endif
18913 }
18914 return pyobj;
18915 }
18916
18917
18918 SWIGINTERN int ART_COPY_set(PyObject *) {
18919 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18920 return 1;
18921 }
18922
18923
18924 SWIGINTERN PyObject *ART_COPY_get(void) {
18925 PyObject *pyobj = 0;
18926
18927 {
18928 #if wxUSE_UNICODE
18929 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18930 #else
18931 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18932 #endif
18933 }
18934 return pyobj;
18935 }
18936
18937
18938 SWIGINTERN int ART_CUT_set(PyObject *) {
18939 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18940 return 1;
18941 }
18942
18943
18944 SWIGINTERN PyObject *ART_CUT_get(void) {
18945 PyObject *pyobj = 0;
18946
18947 {
18948 #if wxUSE_UNICODE
18949 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18950 #else
18951 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18952 #endif
18953 }
18954 return pyobj;
18955 }
18956
18957
18958 SWIGINTERN int ART_PASTE_set(PyObject *) {
18959 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18960 return 1;
18961 }
18962
18963
18964 SWIGINTERN PyObject *ART_PASTE_get(void) {
18965 PyObject *pyobj = 0;
18966
18967 {
18968 #if wxUSE_UNICODE
18969 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18970 #else
18971 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18972 #endif
18973 }
18974 return pyobj;
18975 }
18976
18977
18978 SWIGINTERN int ART_DELETE_set(PyObject *) {
18979 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18980 return 1;
18981 }
18982
18983
18984 SWIGINTERN PyObject *ART_DELETE_get(void) {
18985 PyObject *pyobj = 0;
18986
18987 {
18988 #if wxUSE_UNICODE
18989 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18990 #else
18991 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18992 #endif
18993 }
18994 return pyobj;
18995 }
18996
18997
18998 SWIGINTERN int ART_NEW_set(PyObject *) {
18999 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19000 return 1;
19001 }
19002
19003
19004 SWIGINTERN PyObject *ART_NEW_get(void) {
19005 PyObject *pyobj = 0;
19006
19007 {
19008 #if wxUSE_UNICODE
19009 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19010 #else
19011 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19012 #endif
19013 }
19014 return pyobj;
19015 }
19016
19017
19018 SWIGINTERN int ART_UNDO_set(PyObject *) {
19019 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19020 return 1;
19021 }
19022
19023
19024 SWIGINTERN PyObject *ART_UNDO_get(void) {
19025 PyObject *pyobj = 0;
19026
19027 {
19028 #if wxUSE_UNICODE
19029 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19030 #else
19031 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19032 #endif
19033 }
19034 return pyobj;
19035 }
19036
19037
19038 SWIGINTERN int ART_REDO_set(PyObject *) {
19039 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19040 return 1;
19041 }
19042
19043
19044 SWIGINTERN PyObject *ART_REDO_get(void) {
19045 PyObject *pyobj = 0;
19046
19047 {
19048 #if wxUSE_UNICODE
19049 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19050 #else
19051 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19052 #endif
19053 }
19054 return pyobj;
19055 }
19056
19057
19058 SWIGINTERN int ART_QUIT_set(PyObject *) {
19059 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19060 return 1;
19061 }
19062
19063
19064 SWIGINTERN PyObject *ART_QUIT_get(void) {
19065 PyObject *pyobj = 0;
19066
19067 {
19068 #if wxUSE_UNICODE
19069 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19070 #else
19071 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19072 #endif
19073 }
19074 return pyobj;
19075 }
19076
19077
19078 SWIGINTERN int ART_FIND_set(PyObject *) {
19079 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19080 return 1;
19081 }
19082
19083
19084 SWIGINTERN PyObject *ART_FIND_get(void) {
19085 PyObject *pyobj = 0;
19086
19087 {
19088 #if wxUSE_UNICODE
19089 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19090 #else
19091 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19092 #endif
19093 }
19094 return pyobj;
19095 }
19096
19097
19098 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19099 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19100 return 1;
19101 }
19102
19103
19104 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19105 PyObject *pyobj = 0;
19106
19107 {
19108 #if wxUSE_UNICODE
19109 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19110 #else
19111 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19112 #endif
19113 }
19114 return pyobj;
19115 }
19116
19117
19118 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19119 PyObject *resultobj = 0;
19120 wxPyArtProvider *result = 0 ;
19121
19122 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19123 {
19124 if (!wxPyCheckForApp()) SWIG_fail;
19125 PyThreadState* __tstate = wxPyBeginAllowThreads();
19126 result = (wxPyArtProvider *)new wxPyArtProvider();
19127 wxPyEndAllowThreads(__tstate);
19128 if (PyErr_Occurred()) SWIG_fail;
19129 }
19130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19131 return resultobj;
19132 fail:
19133 return NULL;
19134 }
19135
19136
19137 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19138 PyObject *resultobj = 0;
19139 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19140 void *argp1 = 0 ;
19141 int res1 = 0 ;
19142 PyObject *swig_obj[1] ;
19143
19144 if (!args) SWIG_fail;
19145 swig_obj[0] = args;
19146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19147 if (!SWIG_IsOK(res1)) {
19148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19149 }
19150 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 delete arg1;
19154
19155 wxPyEndAllowThreads(__tstate);
19156 if (PyErr_Occurred()) SWIG_fail;
19157 }
19158 resultobj = SWIG_Py_Void();
19159 return resultobj;
19160 fail:
19161 return NULL;
19162 }
19163
19164
19165 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19166 PyObject *resultobj = 0;
19167 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19168 PyObject *arg2 = (PyObject *) 0 ;
19169 PyObject *arg3 = (PyObject *) 0 ;
19170 void *argp1 = 0 ;
19171 int res1 = 0 ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 PyObject * obj2 = 0 ;
19175 char * kwnames[] = {
19176 (char *) "self",(char *) "self",(char *) "_class", NULL
19177 };
19178
19179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19181 if (!SWIG_IsOK(res1)) {
19182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19183 }
19184 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19185 arg2 = obj1;
19186 arg3 = obj2;
19187 {
19188 PyThreadState* __tstate = wxPyBeginAllowThreads();
19189 (arg1)->_setCallbackInfo(arg2,arg3);
19190 wxPyEndAllowThreads(__tstate);
19191 if (PyErr_Occurred()) SWIG_fail;
19192 }
19193 resultobj = SWIG_Py_Void();
19194 return resultobj;
19195 fail:
19196 return NULL;
19197 }
19198
19199
19200 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19201 PyObject *resultobj = 0;
19202 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19203 int res1 = 0 ;
19204 PyObject * obj0 = 0 ;
19205 char * kwnames[] = {
19206 (char *) "provider", NULL
19207 };
19208
19209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19210 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19213 }
19214 {
19215 PyThreadState* __tstate = wxPyBeginAllowThreads();
19216 wxPyArtProvider::PushProvider(arg1);
19217 wxPyEndAllowThreads(__tstate);
19218 if (PyErr_Occurred()) SWIG_fail;
19219 }
19220 resultobj = SWIG_Py_Void();
19221 return resultobj;
19222 fail:
19223 return NULL;
19224 }
19225
19226
19227 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19228 PyObject *resultobj = 0;
19229 bool result;
19230
19231 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19232 {
19233 PyThreadState* __tstate = wxPyBeginAllowThreads();
19234 result = (bool)wxPyArtProvider::PopProvider();
19235 wxPyEndAllowThreads(__tstate);
19236 if (PyErr_Occurred()) SWIG_fail;
19237 }
19238 {
19239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19240 }
19241 return resultobj;
19242 fail:
19243 return NULL;
19244 }
19245
19246
19247 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19248 PyObject *resultobj = 0;
19249 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19250 bool result;
19251 void *argp1 = 0 ;
19252 int res1 = 0 ;
19253 PyObject * obj0 = 0 ;
19254 char * kwnames[] = {
19255 (char *) "provider", NULL
19256 };
19257
19258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19260 if (!SWIG_IsOK(res1)) {
19261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19262 }
19263 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 {
19271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19272 }
19273 return resultobj;
19274 fail:
19275 return NULL;
19276 }
19277
19278
19279 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19280 PyObject *resultobj = 0;
19281 wxString *arg1 = 0 ;
19282 wxString const &arg2_defvalue = wxPyART_OTHER ;
19283 wxString *arg2 = (wxString *) &arg2_defvalue ;
19284 wxSize const &arg3_defvalue = wxDefaultSize ;
19285 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19286 wxBitmap result;
19287 bool temp1 = false ;
19288 bool temp2 = false ;
19289 wxSize temp3 ;
19290 PyObject * obj0 = 0 ;
19291 PyObject * obj1 = 0 ;
19292 PyObject * obj2 = 0 ;
19293 char * kwnames[] = {
19294 (char *) "id",(char *) "client",(char *) "size", NULL
19295 };
19296
19297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19298 {
19299 arg1 = wxString_in_helper(obj0);
19300 if (arg1 == NULL) SWIG_fail;
19301 temp1 = true;
19302 }
19303 if (obj1) {
19304 {
19305 arg2 = wxString_in_helper(obj1);
19306 if (arg2 == NULL) SWIG_fail;
19307 temp2 = true;
19308 }
19309 }
19310 if (obj2) {
19311 {
19312 arg3 = &temp3;
19313 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19314 }
19315 }
19316 {
19317 if (!wxPyCheckForApp()) SWIG_fail;
19318 PyThreadState* __tstate = wxPyBeginAllowThreads();
19319 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19320 wxPyEndAllowThreads(__tstate);
19321 if (PyErr_Occurred()) SWIG_fail;
19322 }
19323 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19324 {
19325 if (temp1)
19326 delete arg1;
19327 }
19328 {
19329 if (temp2)
19330 delete arg2;
19331 }
19332 return resultobj;
19333 fail:
19334 {
19335 if (temp1)
19336 delete arg1;
19337 }
19338 {
19339 if (temp2)
19340 delete arg2;
19341 }
19342 return NULL;
19343 }
19344
19345
19346 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19347 PyObject *resultobj = 0;
19348 wxString *arg1 = 0 ;
19349 wxString const &arg2_defvalue = wxPyART_OTHER ;
19350 wxString *arg2 = (wxString *) &arg2_defvalue ;
19351 wxSize const &arg3_defvalue = wxDefaultSize ;
19352 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19353 wxIcon result;
19354 bool temp1 = false ;
19355 bool temp2 = false ;
19356 wxSize temp3 ;
19357 PyObject * obj0 = 0 ;
19358 PyObject * obj1 = 0 ;
19359 PyObject * obj2 = 0 ;
19360 char * kwnames[] = {
19361 (char *) "id",(char *) "client",(char *) "size", NULL
19362 };
19363
19364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19365 {
19366 arg1 = wxString_in_helper(obj0);
19367 if (arg1 == NULL) SWIG_fail;
19368 temp1 = true;
19369 }
19370 if (obj1) {
19371 {
19372 arg2 = wxString_in_helper(obj1);
19373 if (arg2 == NULL) SWIG_fail;
19374 temp2 = true;
19375 }
19376 }
19377 if (obj2) {
19378 {
19379 arg3 = &temp3;
19380 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19381 }
19382 }
19383 {
19384 if (!wxPyCheckForApp()) SWIG_fail;
19385 PyThreadState* __tstate = wxPyBeginAllowThreads();
19386 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19387 wxPyEndAllowThreads(__tstate);
19388 if (PyErr_Occurred()) SWIG_fail;
19389 }
19390 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19391 {
19392 if (temp1)
19393 delete arg1;
19394 }
19395 {
19396 if (temp2)
19397 delete arg2;
19398 }
19399 return resultobj;
19400 fail:
19401 {
19402 if (temp1)
19403 delete arg1;
19404 }
19405 {
19406 if (temp2)
19407 delete arg2;
19408 }
19409 return NULL;
19410 }
19411
19412
19413 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19414 PyObject *resultobj = 0;
19415 wxString *arg1 = 0 ;
19416 bool arg2 = (bool) false ;
19417 wxSize result;
19418 bool temp1 = false ;
19419 bool val2 ;
19420 int ecode2 = 0 ;
19421 PyObject * obj0 = 0 ;
19422 PyObject * obj1 = 0 ;
19423 char * kwnames[] = {
19424 (char *) "client",(char *) "platform_dependent", NULL
19425 };
19426
19427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19428 {
19429 arg1 = wxString_in_helper(obj0);
19430 if (arg1 == NULL) SWIG_fail;
19431 temp1 = true;
19432 }
19433 if (obj1) {
19434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19435 if (!SWIG_IsOK(ecode2)) {
19436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19437 }
19438 arg2 = static_cast< bool >(val2);
19439 }
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19447 {
19448 if (temp1)
19449 delete arg1;
19450 }
19451 return resultobj;
19452 fail:
19453 {
19454 if (temp1)
19455 delete arg1;
19456 }
19457 return NULL;
19458 }
19459
19460
19461 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19462 PyObject *resultobj = 0;
19463 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19464 void *argp1 = 0 ;
19465 int res1 = 0 ;
19466 PyObject *swig_obj[1] ;
19467
19468 if (!args) SWIG_fail;
19469 swig_obj[0] = args;
19470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19471 if (!SWIG_IsOK(res1)) {
19472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19473 }
19474 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19475 {
19476 PyThreadState* __tstate = wxPyBeginAllowThreads();
19477 wxPyArtProvider_Destroy(arg1);
19478 wxPyEndAllowThreads(__tstate);
19479 if (PyErr_Occurred()) SWIG_fail;
19480 }
19481 resultobj = SWIG_Py_Void();
19482 return resultobj;
19483 fail:
19484 return NULL;
19485 }
19486
19487
19488 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19489 PyObject *obj;
19490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19491 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19492 return SWIG_Py_Void();
19493 }
19494
19495 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19496 return SWIG_Python_InitShadowInstance(args);
19497 }
19498
19499 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19500 PyObject *resultobj = 0;
19501 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19502 void *argp1 = 0 ;
19503 int res1 = 0 ;
19504 PyObject *swig_obj[1] ;
19505
19506 if (!args) SWIG_fail;
19507 swig_obj[0] = args;
19508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19509 if (!SWIG_IsOK(res1)) {
19510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19511 }
19512 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19513 {
19514 PyThreadState* __tstate = wxPyBeginAllowThreads();
19515 delete arg1;
19516
19517 wxPyEndAllowThreads(__tstate);
19518 if (PyErr_Occurred()) SWIG_fail;
19519 }
19520 resultobj = SWIG_Py_Void();
19521 return resultobj;
19522 fail:
19523 return NULL;
19524 }
19525
19526
19527 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj = 0;
19529 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19530 wxConfigBase *result = 0 ;
19531 int res1 = 0 ;
19532 PyObject * obj0 = 0 ;
19533 char * kwnames[] = {
19534 (char *) "config", NULL
19535 };
19536
19537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19538 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19539 if (!SWIG_IsOK(res1)) {
19540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19541 }
19542 {
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19545 wxPyEndAllowThreads(__tstate);
19546 if (PyErr_Occurred()) SWIG_fail;
19547 }
19548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj = 0;
19557 bool arg1 = (bool) true ;
19558 wxConfigBase *result = 0 ;
19559 bool val1 ;
19560 int ecode1 = 0 ;
19561 PyObject * obj0 = 0 ;
19562 char * kwnames[] = {
19563 (char *) "createOnDemand", NULL
19564 };
19565
19566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19567 if (obj0) {
19568 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19569 if (!SWIG_IsOK(ecode1)) {
19570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19571 }
19572 arg1 = static_cast< bool >(val1);
19573 }
19574 {
19575 PyThreadState* __tstate = wxPyBeginAllowThreads();
19576 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19577 wxPyEndAllowThreads(__tstate);
19578 if (PyErr_Occurred()) SWIG_fail;
19579 }
19580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19588 PyObject *resultobj = 0;
19589 wxConfigBase *result = 0 ;
19590
19591 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19592 {
19593 PyThreadState* __tstate = wxPyBeginAllowThreads();
19594 result = (wxConfigBase *)wxConfigBase::Create();
19595 wxPyEndAllowThreads(__tstate);
19596 if (PyErr_Occurred()) SWIG_fail;
19597 }
19598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19606 PyObject *resultobj = 0;
19607
19608 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 wxConfigBase::DontCreateOnDemand();
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 resultobj = SWIG_Py_Void();
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19623 PyObject *resultobj = 0;
19624 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19625 wxString *arg2 = 0 ;
19626 void *argp1 = 0 ;
19627 int res1 = 0 ;
19628 bool temp2 = false ;
19629 PyObject * obj0 = 0 ;
19630 PyObject * obj1 = 0 ;
19631 char * kwnames[] = {
19632 (char *) "self",(char *) "path", NULL
19633 };
19634
19635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19637 if (!SWIG_IsOK(res1)) {
19638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19639 }
19640 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19641 {
19642 arg2 = wxString_in_helper(obj1);
19643 if (arg2 == NULL) SWIG_fail;
19644 temp2 = true;
19645 }
19646 {
19647 PyThreadState* __tstate = wxPyBeginAllowThreads();
19648 (arg1)->SetPath((wxString const &)*arg2);
19649 wxPyEndAllowThreads(__tstate);
19650 if (PyErr_Occurred()) SWIG_fail;
19651 }
19652 resultobj = SWIG_Py_Void();
19653 {
19654 if (temp2)
19655 delete arg2;
19656 }
19657 return resultobj;
19658 fail:
19659 {
19660 if (temp2)
19661 delete arg2;
19662 }
19663 return NULL;
19664 }
19665
19666
19667 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19668 PyObject *resultobj = 0;
19669 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19670 wxString *result = 0 ;
19671 void *argp1 = 0 ;
19672 int res1 = 0 ;
19673 PyObject *swig_obj[1] ;
19674
19675 if (!args) SWIG_fail;
19676 swig_obj[0] = args;
19677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19678 if (!SWIG_IsOK(res1)) {
19679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19680 }
19681 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19682 {
19683 PyThreadState* __tstate = wxPyBeginAllowThreads();
19684 {
19685 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19686 result = (wxString *) &_result_ref;
19687 }
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 {
19692 #if wxUSE_UNICODE
19693 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19694 #else
19695 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19696 #endif
19697 }
19698 return resultobj;
19699 fail:
19700 return NULL;
19701 }
19702
19703
19704 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19705 PyObject *resultobj = 0;
19706 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19707 PyObject *result = 0 ;
19708 void *argp1 = 0 ;
19709 int res1 = 0 ;
19710 PyObject *swig_obj[1] ;
19711
19712 if (!args) SWIG_fail;
19713 swig_obj[0] = args;
19714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19715 if (!SWIG_IsOK(res1)) {
19716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19717 }
19718 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19719 {
19720 PyThreadState* __tstate = wxPyBeginAllowThreads();
19721 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19722 wxPyEndAllowThreads(__tstate);
19723 if (PyErr_Occurred()) SWIG_fail;
19724 }
19725 resultobj = result;
19726 return resultobj;
19727 fail:
19728 return NULL;
19729 }
19730
19731
19732 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19733 PyObject *resultobj = 0;
19734 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19735 long arg2 ;
19736 PyObject *result = 0 ;
19737 void *argp1 = 0 ;
19738 int res1 = 0 ;
19739 long val2 ;
19740 int ecode2 = 0 ;
19741 PyObject * obj0 = 0 ;
19742 PyObject * obj1 = 0 ;
19743 char * kwnames[] = {
19744 (char *) "self",(char *) "index", NULL
19745 };
19746
19747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19749 if (!SWIG_IsOK(res1)) {
19750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19751 }
19752 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19753 ecode2 = SWIG_AsVal_long(obj1, &val2);
19754 if (!SWIG_IsOK(ecode2)) {
19755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19756 }
19757 arg2 = static_cast< long >(val2);
19758 {
19759 PyThreadState* __tstate = wxPyBeginAllowThreads();
19760 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 resultobj = result;
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19772 PyObject *resultobj = 0;
19773 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19774 PyObject *result = 0 ;
19775 void *argp1 = 0 ;
19776 int res1 = 0 ;
19777 PyObject *swig_obj[1] ;
19778
19779 if (!args) SWIG_fail;
19780 swig_obj[0] = args;
19781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19782 if (!SWIG_IsOK(res1)) {
19783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19784 }
19785 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19786 {
19787 PyThreadState* __tstate = wxPyBeginAllowThreads();
19788 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19789 wxPyEndAllowThreads(__tstate);
19790 if (PyErr_Occurred()) SWIG_fail;
19791 }
19792 resultobj = result;
19793 return resultobj;
19794 fail:
19795 return NULL;
19796 }
19797
19798
19799 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19800 PyObject *resultobj = 0;
19801 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19802 long arg2 ;
19803 PyObject *result = 0 ;
19804 void *argp1 = 0 ;
19805 int res1 = 0 ;
19806 long val2 ;
19807 int ecode2 = 0 ;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 char * kwnames[] = {
19811 (char *) "self",(char *) "index", NULL
19812 };
19813
19814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19816 if (!SWIG_IsOK(res1)) {
19817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19818 }
19819 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19820 ecode2 = SWIG_AsVal_long(obj1, &val2);
19821 if (!SWIG_IsOK(ecode2)) {
19822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19823 }
19824 arg2 = static_cast< long >(val2);
19825 {
19826 PyThreadState* __tstate = wxPyBeginAllowThreads();
19827 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19828 wxPyEndAllowThreads(__tstate);
19829 if (PyErr_Occurred()) SWIG_fail;
19830 }
19831 resultobj = result;
19832 return resultobj;
19833 fail:
19834 return NULL;
19835 }
19836
19837
19838 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19839 PyObject *resultobj = 0;
19840 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19841 bool arg2 = (bool) false ;
19842 size_t result;
19843 void *argp1 = 0 ;
19844 int res1 = 0 ;
19845 bool val2 ;
19846 int ecode2 = 0 ;
19847 PyObject * obj0 = 0 ;
19848 PyObject * obj1 = 0 ;
19849 char * kwnames[] = {
19850 (char *) "self",(char *) "recursive", NULL
19851 };
19852
19853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19855 if (!SWIG_IsOK(res1)) {
19856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19857 }
19858 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19859 if (obj1) {
19860 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19861 if (!SWIG_IsOK(ecode2)) {
19862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19863 }
19864 arg2 = static_cast< bool >(val2);
19865 }
19866 {
19867 PyThreadState* __tstate = wxPyBeginAllowThreads();
19868 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19880 PyObject *resultobj = 0;
19881 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19882 bool arg2 = (bool) false ;
19883 size_t result;
19884 void *argp1 = 0 ;
19885 int res1 = 0 ;
19886 bool val2 ;
19887 int ecode2 = 0 ;
19888 PyObject * obj0 = 0 ;
19889 PyObject * obj1 = 0 ;
19890 char * kwnames[] = {
19891 (char *) "self",(char *) "recursive", NULL
19892 };
19893
19894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19896 if (!SWIG_IsOK(res1)) {
19897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19898 }
19899 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19900 if (obj1) {
19901 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19902 if (!SWIG_IsOK(ecode2)) {
19903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19904 }
19905 arg2 = static_cast< bool >(val2);
19906 }
19907 {
19908 PyThreadState* __tstate = wxPyBeginAllowThreads();
19909 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19910 wxPyEndAllowThreads(__tstate);
19911 if (PyErr_Occurred()) SWIG_fail;
19912 }
19913 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19914 return resultobj;
19915 fail:
19916 return NULL;
19917 }
19918
19919
19920 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19921 PyObject *resultobj = 0;
19922 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19923 wxString *arg2 = 0 ;
19924 bool result;
19925 void *argp1 = 0 ;
19926 int res1 = 0 ;
19927 bool temp2 = false ;
19928 PyObject * obj0 = 0 ;
19929 PyObject * obj1 = 0 ;
19930 char * kwnames[] = {
19931 (char *) "self",(char *) "name", NULL
19932 };
19933
19934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19936 if (!SWIG_IsOK(res1)) {
19937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19938 }
19939 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19940 {
19941 arg2 = wxString_in_helper(obj1);
19942 if (arg2 == NULL) SWIG_fail;
19943 temp2 = true;
19944 }
19945 {
19946 PyThreadState* __tstate = wxPyBeginAllowThreads();
19947 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19948 wxPyEndAllowThreads(__tstate);
19949 if (PyErr_Occurred()) SWIG_fail;
19950 }
19951 {
19952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19953 }
19954 {
19955 if (temp2)
19956 delete arg2;
19957 }
19958 return resultobj;
19959 fail:
19960 {
19961 if (temp2)
19962 delete arg2;
19963 }
19964 return NULL;
19965 }
19966
19967
19968 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19969 PyObject *resultobj = 0;
19970 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19971 wxString *arg2 = 0 ;
19972 bool result;
19973 void *argp1 = 0 ;
19974 int res1 = 0 ;
19975 bool temp2 = false ;
19976 PyObject * obj0 = 0 ;
19977 PyObject * obj1 = 0 ;
19978 char * kwnames[] = {
19979 (char *) "self",(char *) "name", NULL
19980 };
19981
19982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19984 if (!SWIG_IsOK(res1)) {
19985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19986 }
19987 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19988 {
19989 arg2 = wxString_in_helper(obj1);
19990 if (arg2 == NULL) SWIG_fail;
19991 temp2 = true;
19992 }
19993 {
19994 PyThreadState* __tstate = wxPyBeginAllowThreads();
19995 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
19996 wxPyEndAllowThreads(__tstate);
19997 if (PyErr_Occurred()) SWIG_fail;
19998 }
19999 {
20000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20001 }
20002 {
20003 if (temp2)
20004 delete arg2;
20005 }
20006 return resultobj;
20007 fail:
20008 {
20009 if (temp2)
20010 delete arg2;
20011 }
20012 return NULL;
20013 }
20014
20015
20016 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20017 PyObject *resultobj = 0;
20018 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20019 wxString *arg2 = 0 ;
20020 bool result;
20021 void *argp1 = 0 ;
20022 int res1 = 0 ;
20023 bool temp2 = false ;
20024 PyObject * obj0 = 0 ;
20025 PyObject * obj1 = 0 ;
20026 char * kwnames[] = {
20027 (char *) "self",(char *) "name", NULL
20028 };
20029
20030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20032 if (!SWIG_IsOK(res1)) {
20033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20034 }
20035 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20036 {
20037 arg2 = wxString_in_helper(obj1);
20038 if (arg2 == NULL) SWIG_fail;
20039 temp2 = true;
20040 }
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20044 wxPyEndAllowThreads(__tstate);
20045 if (PyErr_Occurred()) SWIG_fail;
20046 }
20047 {
20048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20049 }
20050 {
20051 if (temp2)
20052 delete arg2;
20053 }
20054 return resultobj;
20055 fail:
20056 {
20057 if (temp2)
20058 delete arg2;
20059 }
20060 return NULL;
20061 }
20062
20063
20064 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20065 PyObject *resultobj = 0;
20066 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20067 wxString *arg2 = 0 ;
20068 wxConfigBase::EntryType result;
20069 void *argp1 = 0 ;
20070 int res1 = 0 ;
20071 bool temp2 = false ;
20072 PyObject * obj0 = 0 ;
20073 PyObject * obj1 = 0 ;
20074 char * kwnames[] = {
20075 (char *) "self",(char *) "name", NULL
20076 };
20077
20078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20080 if (!SWIG_IsOK(res1)) {
20081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20082 }
20083 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20084 {
20085 arg2 = wxString_in_helper(obj1);
20086 if (arg2 == NULL) SWIG_fail;
20087 temp2 = true;
20088 }
20089 {
20090 PyThreadState* __tstate = wxPyBeginAllowThreads();
20091 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20092 wxPyEndAllowThreads(__tstate);
20093 if (PyErr_Occurred()) SWIG_fail;
20094 }
20095 resultobj = SWIG_From_int(static_cast< int >(result));
20096 {
20097 if (temp2)
20098 delete arg2;
20099 }
20100 return resultobj;
20101 fail:
20102 {
20103 if (temp2)
20104 delete arg2;
20105 }
20106 return NULL;
20107 }
20108
20109
20110 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20111 PyObject *resultobj = 0;
20112 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20113 wxString *arg2 = 0 ;
20114 wxString const &arg3_defvalue = wxPyEmptyString ;
20115 wxString *arg3 = (wxString *) &arg3_defvalue ;
20116 wxString result;
20117 void *argp1 = 0 ;
20118 int res1 = 0 ;
20119 bool temp2 = false ;
20120 bool temp3 = false ;
20121 PyObject * obj0 = 0 ;
20122 PyObject * obj1 = 0 ;
20123 PyObject * obj2 = 0 ;
20124 char * kwnames[] = {
20125 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20126 };
20127
20128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20130 if (!SWIG_IsOK(res1)) {
20131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20132 }
20133 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20134 {
20135 arg2 = wxString_in_helper(obj1);
20136 if (arg2 == NULL) SWIG_fail;
20137 temp2 = true;
20138 }
20139 if (obj2) {
20140 {
20141 arg3 = wxString_in_helper(obj2);
20142 if (arg3 == NULL) SWIG_fail;
20143 temp3 = true;
20144 }
20145 }
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 {
20153 #if wxUSE_UNICODE
20154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20155 #else
20156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20157 #endif
20158 }
20159 {
20160 if (temp2)
20161 delete arg2;
20162 }
20163 {
20164 if (temp3)
20165 delete arg3;
20166 }
20167 return resultobj;
20168 fail:
20169 {
20170 if (temp2)
20171 delete arg2;
20172 }
20173 {
20174 if (temp3)
20175 delete arg3;
20176 }
20177 return NULL;
20178 }
20179
20180
20181 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20182 PyObject *resultobj = 0;
20183 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20184 wxString *arg2 = 0 ;
20185 long arg3 = (long) 0 ;
20186 long result;
20187 void *argp1 = 0 ;
20188 int res1 = 0 ;
20189 bool temp2 = false ;
20190 long val3 ;
20191 int ecode3 = 0 ;
20192 PyObject * obj0 = 0 ;
20193 PyObject * obj1 = 0 ;
20194 PyObject * obj2 = 0 ;
20195 char * kwnames[] = {
20196 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20197 };
20198
20199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20201 if (!SWIG_IsOK(res1)) {
20202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20203 }
20204 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20205 {
20206 arg2 = wxString_in_helper(obj1);
20207 if (arg2 == NULL) SWIG_fail;
20208 temp2 = true;
20209 }
20210 if (obj2) {
20211 ecode3 = SWIG_AsVal_long(obj2, &val3);
20212 if (!SWIG_IsOK(ecode3)) {
20213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20214 }
20215 arg3 = static_cast< long >(val3);
20216 }
20217 {
20218 PyThreadState* __tstate = wxPyBeginAllowThreads();
20219 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20220 wxPyEndAllowThreads(__tstate);
20221 if (PyErr_Occurred()) SWIG_fail;
20222 }
20223 resultobj = SWIG_From_long(static_cast< long >(result));
20224 {
20225 if (temp2)
20226 delete arg2;
20227 }
20228 return resultobj;
20229 fail:
20230 {
20231 if (temp2)
20232 delete arg2;
20233 }
20234 return NULL;
20235 }
20236
20237
20238 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20239 PyObject *resultobj = 0;
20240 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20241 wxString *arg2 = 0 ;
20242 double arg3 = (double) 0.0 ;
20243 double result;
20244 void *argp1 = 0 ;
20245 int res1 = 0 ;
20246 bool temp2 = false ;
20247 double val3 ;
20248 int ecode3 = 0 ;
20249 PyObject * obj0 = 0 ;
20250 PyObject * obj1 = 0 ;
20251 PyObject * obj2 = 0 ;
20252 char * kwnames[] = {
20253 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20254 };
20255
20256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20258 if (!SWIG_IsOK(res1)) {
20259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20260 }
20261 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20262 {
20263 arg2 = wxString_in_helper(obj1);
20264 if (arg2 == NULL) SWIG_fail;
20265 temp2 = true;
20266 }
20267 if (obj2) {
20268 ecode3 = SWIG_AsVal_double(obj2, &val3);
20269 if (!SWIG_IsOK(ecode3)) {
20270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20271 }
20272 arg3 = static_cast< double >(val3);
20273 }
20274 {
20275 PyThreadState* __tstate = wxPyBeginAllowThreads();
20276 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20277 wxPyEndAllowThreads(__tstate);
20278 if (PyErr_Occurred()) SWIG_fail;
20279 }
20280 resultobj = SWIG_From_double(static_cast< double >(result));
20281 {
20282 if (temp2)
20283 delete arg2;
20284 }
20285 return resultobj;
20286 fail:
20287 {
20288 if (temp2)
20289 delete arg2;
20290 }
20291 return NULL;
20292 }
20293
20294
20295 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20296 PyObject *resultobj = 0;
20297 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20298 wxString *arg2 = 0 ;
20299 bool arg3 = (bool) false ;
20300 bool result;
20301 void *argp1 = 0 ;
20302 int res1 = 0 ;
20303 bool temp2 = false ;
20304 bool val3 ;
20305 int ecode3 = 0 ;
20306 PyObject * obj0 = 0 ;
20307 PyObject * obj1 = 0 ;
20308 PyObject * obj2 = 0 ;
20309 char * kwnames[] = {
20310 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20311 };
20312
20313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20315 if (!SWIG_IsOK(res1)) {
20316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20317 }
20318 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20319 {
20320 arg2 = wxString_in_helper(obj1);
20321 if (arg2 == NULL) SWIG_fail;
20322 temp2 = true;
20323 }
20324 if (obj2) {
20325 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20326 if (!SWIG_IsOK(ecode3)) {
20327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20328 }
20329 arg3 = static_cast< bool >(val3);
20330 }
20331 {
20332 PyThreadState* __tstate = wxPyBeginAllowThreads();
20333 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 {
20338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20339 }
20340 {
20341 if (temp2)
20342 delete arg2;
20343 }
20344 return resultobj;
20345 fail:
20346 {
20347 if (temp2)
20348 delete arg2;
20349 }
20350 return NULL;
20351 }
20352
20353
20354 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20355 PyObject *resultobj = 0;
20356 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20357 wxString *arg2 = 0 ;
20358 wxString *arg3 = 0 ;
20359 bool result;
20360 void *argp1 = 0 ;
20361 int res1 = 0 ;
20362 bool temp2 = false ;
20363 bool temp3 = false ;
20364 PyObject * obj0 = 0 ;
20365 PyObject * obj1 = 0 ;
20366 PyObject * obj2 = 0 ;
20367 char * kwnames[] = {
20368 (char *) "self",(char *) "key",(char *) "value", NULL
20369 };
20370
20371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20373 if (!SWIG_IsOK(res1)) {
20374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20375 }
20376 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20377 {
20378 arg2 = wxString_in_helper(obj1);
20379 if (arg2 == NULL) SWIG_fail;
20380 temp2 = true;
20381 }
20382 {
20383 arg3 = wxString_in_helper(obj2);
20384 if (arg3 == NULL) SWIG_fail;
20385 temp3 = true;
20386 }
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 {
20394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20395 }
20396 {
20397 if (temp2)
20398 delete arg2;
20399 }
20400 {
20401 if (temp3)
20402 delete arg3;
20403 }
20404 return resultobj;
20405 fail:
20406 {
20407 if (temp2)
20408 delete arg2;
20409 }
20410 {
20411 if (temp3)
20412 delete arg3;
20413 }
20414 return NULL;
20415 }
20416
20417
20418 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20419 PyObject *resultobj = 0;
20420 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20421 wxString *arg2 = 0 ;
20422 long arg3 ;
20423 bool result;
20424 void *argp1 = 0 ;
20425 int res1 = 0 ;
20426 bool temp2 = false ;
20427 long val3 ;
20428 int ecode3 = 0 ;
20429 PyObject * obj0 = 0 ;
20430 PyObject * obj1 = 0 ;
20431 PyObject * obj2 = 0 ;
20432 char * kwnames[] = {
20433 (char *) "self",(char *) "key",(char *) "value", NULL
20434 };
20435
20436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20438 if (!SWIG_IsOK(res1)) {
20439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20440 }
20441 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20442 {
20443 arg2 = wxString_in_helper(obj1);
20444 if (arg2 == NULL) SWIG_fail;
20445 temp2 = true;
20446 }
20447 ecode3 = SWIG_AsVal_long(obj2, &val3);
20448 if (!SWIG_IsOK(ecode3)) {
20449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20450 }
20451 arg3 = static_cast< long >(val3);
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 {
20459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20460 }
20461 {
20462 if (temp2)
20463 delete arg2;
20464 }
20465 return resultobj;
20466 fail:
20467 {
20468 if (temp2)
20469 delete arg2;
20470 }
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20476 PyObject *resultobj = 0;
20477 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20478 wxString *arg2 = 0 ;
20479 double arg3 ;
20480 bool result;
20481 void *argp1 = 0 ;
20482 int res1 = 0 ;
20483 bool temp2 = false ;
20484 double val3 ;
20485 int ecode3 = 0 ;
20486 PyObject * obj0 = 0 ;
20487 PyObject * obj1 = 0 ;
20488 PyObject * obj2 = 0 ;
20489 char * kwnames[] = {
20490 (char *) "self",(char *) "key",(char *) "value", NULL
20491 };
20492
20493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20495 if (!SWIG_IsOK(res1)) {
20496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20497 }
20498 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20499 {
20500 arg2 = wxString_in_helper(obj1);
20501 if (arg2 == NULL) SWIG_fail;
20502 temp2 = true;
20503 }
20504 ecode3 = SWIG_AsVal_double(obj2, &val3);
20505 if (!SWIG_IsOK(ecode3)) {
20506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20507 }
20508 arg3 = static_cast< double >(val3);
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 {
20516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20517 }
20518 {
20519 if (temp2)
20520 delete arg2;
20521 }
20522 return resultobj;
20523 fail:
20524 {
20525 if (temp2)
20526 delete arg2;
20527 }
20528 return NULL;
20529 }
20530
20531
20532 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20533 PyObject *resultobj = 0;
20534 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20535 wxString *arg2 = 0 ;
20536 bool arg3 ;
20537 bool result;
20538 void *argp1 = 0 ;
20539 int res1 = 0 ;
20540 bool temp2 = false ;
20541 bool val3 ;
20542 int ecode3 = 0 ;
20543 PyObject * obj0 = 0 ;
20544 PyObject * obj1 = 0 ;
20545 PyObject * obj2 = 0 ;
20546 char * kwnames[] = {
20547 (char *) "self",(char *) "key",(char *) "value", NULL
20548 };
20549
20550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20552 if (!SWIG_IsOK(res1)) {
20553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20554 }
20555 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20556 {
20557 arg2 = wxString_in_helper(obj1);
20558 if (arg2 == NULL) SWIG_fail;
20559 temp2 = true;
20560 }
20561 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20562 if (!SWIG_IsOK(ecode3)) {
20563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20564 }
20565 arg3 = static_cast< bool >(val3);
20566 {
20567 PyThreadState* __tstate = wxPyBeginAllowThreads();
20568 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20569 wxPyEndAllowThreads(__tstate);
20570 if (PyErr_Occurred()) SWIG_fail;
20571 }
20572 {
20573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20574 }
20575 {
20576 if (temp2)
20577 delete arg2;
20578 }
20579 return resultobj;
20580 fail:
20581 {
20582 if (temp2)
20583 delete arg2;
20584 }
20585 return NULL;
20586 }
20587
20588
20589 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20590 PyObject *resultobj = 0;
20591 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20592 bool arg2 = (bool) false ;
20593 bool result;
20594 void *argp1 = 0 ;
20595 int res1 = 0 ;
20596 bool val2 ;
20597 int ecode2 = 0 ;
20598 PyObject * obj0 = 0 ;
20599 PyObject * obj1 = 0 ;
20600 char * kwnames[] = {
20601 (char *) "self",(char *) "currentOnly", NULL
20602 };
20603
20604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20608 }
20609 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20610 if (obj1) {
20611 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20612 if (!SWIG_IsOK(ecode2)) {
20613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20614 }
20615 arg2 = static_cast< bool >(val2);
20616 }
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (bool)(arg1)->Flush(arg2);
20620 wxPyEndAllowThreads(__tstate);
20621 if (PyErr_Occurred()) SWIG_fail;
20622 }
20623 {
20624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20625 }
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20633 PyObject *resultobj = 0;
20634 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20635 wxString *arg2 = 0 ;
20636 wxString *arg3 = 0 ;
20637 bool result;
20638 void *argp1 = 0 ;
20639 int res1 = 0 ;
20640 bool temp2 = false ;
20641 bool temp3 = false ;
20642 PyObject * obj0 = 0 ;
20643 PyObject * obj1 = 0 ;
20644 PyObject * obj2 = 0 ;
20645 char * kwnames[] = {
20646 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20647 };
20648
20649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20651 if (!SWIG_IsOK(res1)) {
20652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20653 }
20654 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20655 {
20656 arg2 = wxString_in_helper(obj1);
20657 if (arg2 == NULL) SWIG_fail;
20658 temp2 = true;
20659 }
20660 {
20661 arg3 = wxString_in_helper(obj2);
20662 if (arg3 == NULL) SWIG_fail;
20663 temp3 = true;
20664 }
20665 {
20666 PyThreadState* __tstate = wxPyBeginAllowThreads();
20667 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20668 wxPyEndAllowThreads(__tstate);
20669 if (PyErr_Occurred()) SWIG_fail;
20670 }
20671 {
20672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20673 }
20674 {
20675 if (temp2)
20676 delete arg2;
20677 }
20678 {
20679 if (temp3)
20680 delete arg3;
20681 }
20682 return resultobj;
20683 fail:
20684 {
20685 if (temp2)
20686 delete arg2;
20687 }
20688 {
20689 if (temp3)
20690 delete arg3;
20691 }
20692 return NULL;
20693 }
20694
20695
20696 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20697 PyObject *resultobj = 0;
20698 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20699 wxString *arg2 = 0 ;
20700 wxString *arg3 = 0 ;
20701 bool result;
20702 void *argp1 = 0 ;
20703 int res1 = 0 ;
20704 bool temp2 = false ;
20705 bool temp3 = false ;
20706 PyObject * obj0 = 0 ;
20707 PyObject * obj1 = 0 ;
20708 PyObject * obj2 = 0 ;
20709 char * kwnames[] = {
20710 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20711 };
20712
20713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20715 if (!SWIG_IsOK(res1)) {
20716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20717 }
20718 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20719 {
20720 arg2 = wxString_in_helper(obj1);
20721 if (arg2 == NULL) SWIG_fail;
20722 temp2 = true;
20723 }
20724 {
20725 arg3 = wxString_in_helper(obj2);
20726 if (arg3 == NULL) SWIG_fail;
20727 temp3 = true;
20728 }
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 {
20736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20737 }
20738 {
20739 if (temp2)
20740 delete arg2;
20741 }
20742 {
20743 if (temp3)
20744 delete arg3;
20745 }
20746 return resultobj;
20747 fail:
20748 {
20749 if (temp2)
20750 delete arg2;
20751 }
20752 {
20753 if (temp3)
20754 delete arg3;
20755 }
20756 return NULL;
20757 }
20758
20759
20760 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20761 PyObject *resultobj = 0;
20762 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20763 wxString *arg2 = 0 ;
20764 bool arg3 = (bool) true ;
20765 bool result;
20766 void *argp1 = 0 ;
20767 int res1 = 0 ;
20768 bool temp2 = false ;
20769 bool val3 ;
20770 int ecode3 = 0 ;
20771 PyObject * obj0 = 0 ;
20772 PyObject * obj1 = 0 ;
20773 PyObject * obj2 = 0 ;
20774 char * kwnames[] = {
20775 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20776 };
20777
20778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20780 if (!SWIG_IsOK(res1)) {
20781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20782 }
20783 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20784 {
20785 arg2 = wxString_in_helper(obj1);
20786 if (arg2 == NULL) SWIG_fail;
20787 temp2 = true;
20788 }
20789 if (obj2) {
20790 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20791 if (!SWIG_IsOK(ecode3)) {
20792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20793 }
20794 arg3 = static_cast< bool >(val3);
20795 }
20796 {
20797 PyThreadState* __tstate = wxPyBeginAllowThreads();
20798 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 {
20803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20804 }
20805 {
20806 if (temp2)
20807 delete arg2;
20808 }
20809 return resultobj;
20810 fail:
20811 {
20812 if (temp2)
20813 delete arg2;
20814 }
20815 return NULL;
20816 }
20817
20818
20819 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20820 PyObject *resultobj = 0;
20821 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20822 wxString *arg2 = 0 ;
20823 bool result;
20824 void *argp1 = 0 ;
20825 int res1 = 0 ;
20826 bool temp2 = false ;
20827 PyObject * obj0 = 0 ;
20828 PyObject * obj1 = 0 ;
20829 char * kwnames[] = {
20830 (char *) "self",(char *) "key", NULL
20831 };
20832
20833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20835 if (!SWIG_IsOK(res1)) {
20836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20837 }
20838 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20839 {
20840 arg2 = wxString_in_helper(obj1);
20841 if (arg2 == NULL) SWIG_fail;
20842 temp2 = true;
20843 }
20844 {
20845 PyThreadState* __tstate = wxPyBeginAllowThreads();
20846 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20847 wxPyEndAllowThreads(__tstate);
20848 if (PyErr_Occurred()) SWIG_fail;
20849 }
20850 {
20851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20852 }
20853 {
20854 if (temp2)
20855 delete arg2;
20856 }
20857 return resultobj;
20858 fail:
20859 {
20860 if (temp2)
20861 delete arg2;
20862 }
20863 return NULL;
20864 }
20865
20866
20867 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20868 PyObject *resultobj = 0;
20869 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20870 bool result;
20871 void *argp1 = 0 ;
20872 int res1 = 0 ;
20873 PyObject *swig_obj[1] ;
20874
20875 if (!args) SWIG_fail;
20876 swig_obj[0] = args;
20877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20878 if (!SWIG_IsOK(res1)) {
20879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20880 }
20881 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20882 {
20883 PyThreadState* __tstate = wxPyBeginAllowThreads();
20884 result = (bool)(arg1)->DeleteAll();
20885 wxPyEndAllowThreads(__tstate);
20886 if (PyErr_Occurred()) SWIG_fail;
20887 }
20888 {
20889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20890 }
20891 return resultobj;
20892 fail:
20893 return NULL;
20894 }
20895
20896
20897 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20898 PyObject *resultobj = 0;
20899 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20900 bool arg2 = (bool) true ;
20901 void *argp1 = 0 ;
20902 int res1 = 0 ;
20903 bool val2 ;
20904 int ecode2 = 0 ;
20905 PyObject * obj0 = 0 ;
20906 PyObject * obj1 = 0 ;
20907 char * kwnames[] = {
20908 (char *) "self",(char *) "doIt", NULL
20909 };
20910
20911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20913 if (!SWIG_IsOK(res1)) {
20914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20915 }
20916 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20917 if (obj1) {
20918 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20919 if (!SWIG_IsOK(ecode2)) {
20920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20921 }
20922 arg2 = static_cast< bool >(val2);
20923 }
20924 {
20925 PyThreadState* __tstate = wxPyBeginAllowThreads();
20926 (arg1)->SetExpandEnvVars(arg2);
20927 wxPyEndAllowThreads(__tstate);
20928 if (PyErr_Occurred()) SWIG_fail;
20929 }
20930 resultobj = SWIG_Py_Void();
20931 return resultobj;
20932 fail:
20933 return NULL;
20934 }
20935
20936
20937 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20938 PyObject *resultobj = 0;
20939 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20940 bool result;
20941 void *argp1 = 0 ;
20942 int res1 = 0 ;
20943 PyObject *swig_obj[1] ;
20944
20945 if (!args) SWIG_fail;
20946 swig_obj[0] = args;
20947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20948 if (!SWIG_IsOK(res1)) {
20949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20950 }
20951 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20955 wxPyEndAllowThreads(__tstate);
20956 if (PyErr_Occurred()) SWIG_fail;
20957 }
20958 {
20959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20960 }
20961 return resultobj;
20962 fail:
20963 return NULL;
20964 }
20965
20966
20967 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20968 PyObject *resultobj = 0;
20969 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20970 bool arg2 = (bool) true ;
20971 void *argp1 = 0 ;
20972 int res1 = 0 ;
20973 bool val2 ;
20974 int ecode2 = 0 ;
20975 PyObject * obj0 = 0 ;
20976 PyObject * obj1 = 0 ;
20977 char * kwnames[] = {
20978 (char *) "self",(char *) "doIt", NULL
20979 };
20980
20981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
20982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20983 if (!SWIG_IsOK(res1)) {
20984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20985 }
20986 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20987 if (obj1) {
20988 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20989 if (!SWIG_IsOK(ecode2)) {
20990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
20991 }
20992 arg2 = static_cast< bool >(val2);
20993 }
20994 {
20995 PyThreadState* __tstate = wxPyBeginAllowThreads();
20996 (arg1)->SetRecordDefaults(arg2);
20997 wxPyEndAllowThreads(__tstate);
20998 if (PyErr_Occurred()) SWIG_fail;
20999 }
21000 resultobj = SWIG_Py_Void();
21001 return resultobj;
21002 fail:
21003 return NULL;
21004 }
21005
21006
21007 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21008 PyObject *resultobj = 0;
21009 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21010 bool result;
21011 void *argp1 = 0 ;
21012 int res1 = 0 ;
21013 PyObject *swig_obj[1] ;
21014
21015 if (!args) SWIG_fail;
21016 swig_obj[0] = args;
21017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21018 if (!SWIG_IsOK(res1)) {
21019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21020 }
21021 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21022 {
21023 PyThreadState* __tstate = wxPyBeginAllowThreads();
21024 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21025 wxPyEndAllowThreads(__tstate);
21026 if (PyErr_Occurred()) SWIG_fail;
21027 }
21028 {
21029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21030 }
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21038 PyObject *resultobj = 0;
21039 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21040 wxString *arg2 = 0 ;
21041 wxString result;
21042 void *argp1 = 0 ;
21043 int res1 = 0 ;
21044 bool temp2 = false ;
21045 PyObject * obj0 = 0 ;
21046 PyObject * obj1 = 0 ;
21047 char * kwnames[] = {
21048 (char *) "self",(char *) "str", NULL
21049 };
21050
21051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21053 if (!SWIG_IsOK(res1)) {
21054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21055 }
21056 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21057 {
21058 arg2 = wxString_in_helper(obj1);
21059 if (arg2 == NULL) SWIG_fail;
21060 temp2 = true;
21061 }
21062 {
21063 PyThreadState* __tstate = wxPyBeginAllowThreads();
21064 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21065 wxPyEndAllowThreads(__tstate);
21066 if (PyErr_Occurred()) SWIG_fail;
21067 }
21068 {
21069 #if wxUSE_UNICODE
21070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21071 #else
21072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21073 #endif
21074 }
21075 {
21076 if (temp2)
21077 delete arg2;
21078 }
21079 return resultobj;
21080 fail:
21081 {
21082 if (temp2)
21083 delete arg2;
21084 }
21085 return NULL;
21086 }
21087
21088
21089 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21090 PyObject *resultobj = 0;
21091 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21092 wxString result;
21093 void *argp1 = 0 ;
21094 int res1 = 0 ;
21095 PyObject *swig_obj[1] ;
21096
21097 if (!args) SWIG_fail;
21098 swig_obj[0] = args;
21099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21100 if (!SWIG_IsOK(res1)) {
21101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21102 }
21103 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21104 {
21105 PyThreadState* __tstate = wxPyBeginAllowThreads();
21106 result = ((wxConfigBase const *)arg1)->GetAppName();
21107 wxPyEndAllowThreads(__tstate);
21108 if (PyErr_Occurred()) SWIG_fail;
21109 }
21110 {
21111 #if wxUSE_UNICODE
21112 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21113 #else
21114 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21115 #endif
21116 }
21117 return resultobj;
21118 fail:
21119 return NULL;
21120 }
21121
21122
21123 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21124 PyObject *resultobj = 0;
21125 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21126 wxString result;
21127 void *argp1 = 0 ;
21128 int res1 = 0 ;
21129 PyObject *swig_obj[1] ;
21130
21131 if (!args) SWIG_fail;
21132 swig_obj[0] = args;
21133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21134 if (!SWIG_IsOK(res1)) {
21135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21136 }
21137 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 result = ((wxConfigBase const *)arg1)->GetVendorName();
21141 wxPyEndAllowThreads(__tstate);
21142 if (PyErr_Occurred()) SWIG_fail;
21143 }
21144 {
21145 #if wxUSE_UNICODE
21146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21147 #else
21148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21149 #endif
21150 }
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21158 PyObject *resultobj = 0;
21159 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21160 wxString *arg2 = 0 ;
21161 void *argp1 = 0 ;
21162 int res1 = 0 ;
21163 bool temp2 = false ;
21164 PyObject * obj0 = 0 ;
21165 PyObject * obj1 = 0 ;
21166 char * kwnames[] = {
21167 (char *) "self",(char *) "appName", NULL
21168 };
21169
21170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21172 if (!SWIG_IsOK(res1)) {
21173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21174 }
21175 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21176 {
21177 arg2 = wxString_in_helper(obj1);
21178 if (arg2 == NULL) SWIG_fail;
21179 temp2 = true;
21180 }
21181 {
21182 PyThreadState* __tstate = wxPyBeginAllowThreads();
21183 (arg1)->SetAppName((wxString const &)*arg2);
21184 wxPyEndAllowThreads(__tstate);
21185 if (PyErr_Occurred()) SWIG_fail;
21186 }
21187 resultobj = SWIG_Py_Void();
21188 {
21189 if (temp2)
21190 delete arg2;
21191 }
21192 return resultobj;
21193 fail:
21194 {
21195 if (temp2)
21196 delete arg2;
21197 }
21198 return NULL;
21199 }
21200
21201
21202 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21203 PyObject *resultobj = 0;
21204 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21205 wxString *arg2 = 0 ;
21206 void *argp1 = 0 ;
21207 int res1 = 0 ;
21208 bool temp2 = false ;
21209 PyObject * obj0 = 0 ;
21210 PyObject * obj1 = 0 ;
21211 char * kwnames[] = {
21212 (char *) "self",(char *) "vendorName", NULL
21213 };
21214
21215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21217 if (!SWIG_IsOK(res1)) {
21218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21219 }
21220 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21221 {
21222 arg2 = wxString_in_helper(obj1);
21223 if (arg2 == NULL) SWIG_fail;
21224 temp2 = true;
21225 }
21226 {
21227 PyThreadState* __tstate = wxPyBeginAllowThreads();
21228 (arg1)->SetVendorName((wxString const &)*arg2);
21229 wxPyEndAllowThreads(__tstate);
21230 if (PyErr_Occurred()) SWIG_fail;
21231 }
21232 resultobj = SWIG_Py_Void();
21233 {
21234 if (temp2)
21235 delete arg2;
21236 }
21237 return resultobj;
21238 fail:
21239 {
21240 if (temp2)
21241 delete arg2;
21242 }
21243 return NULL;
21244 }
21245
21246
21247 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21248 PyObject *resultobj = 0;
21249 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21250 long arg2 ;
21251 void *argp1 = 0 ;
21252 int res1 = 0 ;
21253 long val2 ;
21254 int ecode2 = 0 ;
21255 PyObject * obj0 = 0 ;
21256 PyObject * obj1 = 0 ;
21257 char * kwnames[] = {
21258 (char *) "self",(char *) "style", NULL
21259 };
21260
21261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21263 if (!SWIG_IsOK(res1)) {
21264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21265 }
21266 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21267 ecode2 = SWIG_AsVal_long(obj1, &val2);
21268 if (!SWIG_IsOK(ecode2)) {
21269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21270 }
21271 arg2 = static_cast< long >(val2);
21272 {
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 (arg1)->SetStyle(arg2);
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 resultobj = SWIG_Py_Void();
21279 return resultobj;
21280 fail:
21281 return NULL;
21282 }
21283
21284
21285 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21286 PyObject *resultobj = 0;
21287 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21288 long result;
21289 void *argp1 = 0 ;
21290 int res1 = 0 ;
21291 PyObject *swig_obj[1] ;
21292
21293 if (!args) SWIG_fail;
21294 swig_obj[0] = args;
21295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21296 if (!SWIG_IsOK(res1)) {
21297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21298 }
21299 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21300 {
21301 PyThreadState* __tstate = wxPyBeginAllowThreads();
21302 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_From_long(static_cast< long >(result));
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21314 PyObject *obj;
21315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21316 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21317 return SWIG_Py_Void();
21318 }
21319
21320 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21321 PyObject *resultobj = 0;
21322 wxString const &arg1_defvalue = wxPyEmptyString ;
21323 wxString *arg1 = (wxString *) &arg1_defvalue ;
21324 wxString const &arg2_defvalue = wxPyEmptyString ;
21325 wxString *arg2 = (wxString *) &arg2_defvalue ;
21326 wxString const &arg3_defvalue = wxPyEmptyString ;
21327 wxString *arg3 = (wxString *) &arg3_defvalue ;
21328 wxString const &arg4_defvalue = wxPyEmptyString ;
21329 wxString *arg4 = (wxString *) &arg4_defvalue ;
21330 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21331 wxConfig *result = 0 ;
21332 bool temp1 = false ;
21333 bool temp2 = false ;
21334 bool temp3 = false ;
21335 bool temp4 = false ;
21336 long val5 ;
21337 int ecode5 = 0 ;
21338 PyObject * obj0 = 0 ;
21339 PyObject * obj1 = 0 ;
21340 PyObject * obj2 = 0 ;
21341 PyObject * obj3 = 0 ;
21342 PyObject * obj4 = 0 ;
21343 char * kwnames[] = {
21344 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21345 };
21346
21347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21348 if (obj0) {
21349 {
21350 arg1 = wxString_in_helper(obj0);
21351 if (arg1 == NULL) SWIG_fail;
21352 temp1 = true;
21353 }
21354 }
21355 if (obj1) {
21356 {
21357 arg2 = wxString_in_helper(obj1);
21358 if (arg2 == NULL) SWIG_fail;
21359 temp2 = true;
21360 }
21361 }
21362 if (obj2) {
21363 {
21364 arg3 = wxString_in_helper(obj2);
21365 if (arg3 == NULL) SWIG_fail;
21366 temp3 = true;
21367 }
21368 }
21369 if (obj3) {
21370 {
21371 arg4 = wxString_in_helper(obj3);
21372 if (arg4 == NULL) SWIG_fail;
21373 temp4 = true;
21374 }
21375 }
21376 if (obj4) {
21377 ecode5 = SWIG_AsVal_long(obj4, &val5);
21378 if (!SWIG_IsOK(ecode5)) {
21379 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21380 }
21381 arg5 = static_cast< long >(val5);
21382 }
21383 {
21384 PyThreadState* __tstate = wxPyBeginAllowThreads();
21385 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21386 wxPyEndAllowThreads(__tstate);
21387 if (PyErr_Occurred()) SWIG_fail;
21388 }
21389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21390 {
21391 if (temp1)
21392 delete arg1;
21393 }
21394 {
21395 if (temp2)
21396 delete arg2;
21397 }
21398 {
21399 if (temp3)
21400 delete arg3;
21401 }
21402 {
21403 if (temp4)
21404 delete arg4;
21405 }
21406 return resultobj;
21407 fail:
21408 {
21409 if (temp1)
21410 delete arg1;
21411 }
21412 {
21413 if (temp2)
21414 delete arg2;
21415 }
21416 {
21417 if (temp3)
21418 delete arg3;
21419 }
21420 {
21421 if (temp4)
21422 delete arg4;
21423 }
21424 return NULL;
21425 }
21426
21427
21428 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21429 PyObject *resultobj = 0;
21430 wxConfig *arg1 = (wxConfig *) 0 ;
21431 void *argp1 = 0 ;
21432 int res1 = 0 ;
21433 PyObject *swig_obj[1] ;
21434
21435 if (!args) SWIG_fail;
21436 swig_obj[0] = args;
21437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21438 if (!SWIG_IsOK(res1)) {
21439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21440 }
21441 arg1 = reinterpret_cast< wxConfig * >(argp1);
21442 {
21443 PyThreadState* __tstate = wxPyBeginAllowThreads();
21444 delete arg1;
21445
21446 wxPyEndAllowThreads(__tstate);
21447 if (PyErr_Occurred()) SWIG_fail;
21448 }
21449 resultobj = SWIG_Py_Void();
21450 return resultobj;
21451 fail:
21452 return NULL;
21453 }
21454
21455
21456 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21457 PyObject *obj;
21458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21459 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21460 return SWIG_Py_Void();
21461 }
21462
21463 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21464 return SWIG_Python_InitShadowInstance(args);
21465 }
21466
21467 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21468 PyObject *resultobj = 0;
21469 wxString const &arg1_defvalue = wxPyEmptyString ;
21470 wxString *arg1 = (wxString *) &arg1_defvalue ;
21471 wxString const &arg2_defvalue = wxPyEmptyString ;
21472 wxString *arg2 = (wxString *) &arg2_defvalue ;
21473 wxString const &arg3_defvalue = wxPyEmptyString ;
21474 wxString *arg3 = (wxString *) &arg3_defvalue ;
21475 wxString const &arg4_defvalue = wxPyEmptyString ;
21476 wxString *arg4 = (wxString *) &arg4_defvalue ;
21477 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21478 wxFileConfig *result = 0 ;
21479 bool temp1 = false ;
21480 bool temp2 = false ;
21481 bool temp3 = false ;
21482 bool temp4 = false ;
21483 long val5 ;
21484 int ecode5 = 0 ;
21485 PyObject * obj0 = 0 ;
21486 PyObject * obj1 = 0 ;
21487 PyObject * obj2 = 0 ;
21488 PyObject * obj3 = 0 ;
21489 PyObject * obj4 = 0 ;
21490 char * kwnames[] = {
21491 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21492 };
21493
21494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21495 if (obj0) {
21496 {
21497 arg1 = wxString_in_helper(obj0);
21498 if (arg1 == NULL) SWIG_fail;
21499 temp1 = true;
21500 }
21501 }
21502 if (obj1) {
21503 {
21504 arg2 = wxString_in_helper(obj1);
21505 if (arg2 == NULL) SWIG_fail;
21506 temp2 = true;
21507 }
21508 }
21509 if (obj2) {
21510 {
21511 arg3 = wxString_in_helper(obj2);
21512 if (arg3 == NULL) SWIG_fail;
21513 temp3 = true;
21514 }
21515 }
21516 if (obj3) {
21517 {
21518 arg4 = wxString_in_helper(obj3);
21519 if (arg4 == NULL) SWIG_fail;
21520 temp4 = true;
21521 }
21522 }
21523 if (obj4) {
21524 ecode5 = SWIG_AsVal_long(obj4, &val5);
21525 if (!SWIG_IsOK(ecode5)) {
21526 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21527 }
21528 arg5 = static_cast< long >(val5);
21529 }
21530 {
21531 PyThreadState* __tstate = wxPyBeginAllowThreads();
21532 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21533 wxPyEndAllowThreads(__tstate);
21534 if (PyErr_Occurred()) SWIG_fail;
21535 }
21536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21537 {
21538 if (temp1)
21539 delete arg1;
21540 }
21541 {
21542 if (temp2)
21543 delete arg2;
21544 }
21545 {
21546 if (temp3)
21547 delete arg3;
21548 }
21549 {
21550 if (temp4)
21551 delete arg4;
21552 }
21553 return resultobj;
21554 fail:
21555 {
21556 if (temp1)
21557 delete arg1;
21558 }
21559 {
21560 if (temp2)
21561 delete arg2;
21562 }
21563 {
21564 if (temp3)
21565 delete arg3;
21566 }
21567 {
21568 if (temp4)
21569 delete arg4;
21570 }
21571 return NULL;
21572 }
21573
21574
21575 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21576 PyObject *resultobj = 0;
21577 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21578 void *argp1 = 0 ;
21579 int res1 = 0 ;
21580 PyObject *swig_obj[1] ;
21581
21582 if (!args) SWIG_fail;
21583 swig_obj[0] = args;
21584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21585 if (!SWIG_IsOK(res1)) {
21586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21587 }
21588 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21589 {
21590 PyThreadState* __tstate = wxPyBeginAllowThreads();
21591 delete arg1;
21592
21593 wxPyEndAllowThreads(__tstate);
21594 if (PyErr_Occurred()) SWIG_fail;
21595 }
21596 resultobj = SWIG_Py_Void();
21597 return resultobj;
21598 fail:
21599 return NULL;
21600 }
21601
21602
21603 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21604 PyObject *obj;
21605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21606 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21607 return SWIG_Py_Void();
21608 }
21609
21610 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21611 return SWIG_Python_InitShadowInstance(args);
21612 }
21613
21614 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21615 PyObject *resultobj = 0;
21616 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21617 wxString *arg2 = 0 ;
21618 wxConfigPathChanger *result = 0 ;
21619 void *argp1 = 0 ;
21620 int res1 = 0 ;
21621 bool temp2 = false ;
21622 PyObject * obj0 = 0 ;
21623 PyObject * obj1 = 0 ;
21624 char * kwnames[] = {
21625 (char *) "config",(char *) "entry", NULL
21626 };
21627
21628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21630 if (!SWIG_IsOK(res1)) {
21631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21632 }
21633 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21634 {
21635 arg2 = wxString_in_helper(obj1);
21636 if (arg2 == NULL) SWIG_fail;
21637 temp2 = true;
21638 }
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21642 wxPyEndAllowThreads(__tstate);
21643 if (PyErr_Occurred()) SWIG_fail;
21644 }
21645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21646 {
21647 if (temp2)
21648 delete arg2;
21649 }
21650 return resultobj;
21651 fail:
21652 {
21653 if (temp2)
21654 delete arg2;
21655 }
21656 return NULL;
21657 }
21658
21659
21660 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21661 PyObject *resultobj = 0;
21662 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21663 void *argp1 = 0 ;
21664 int res1 = 0 ;
21665 PyObject *swig_obj[1] ;
21666
21667 if (!args) SWIG_fail;
21668 swig_obj[0] = args;
21669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21670 if (!SWIG_IsOK(res1)) {
21671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21672 }
21673 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21674 {
21675 PyThreadState* __tstate = wxPyBeginAllowThreads();
21676 delete arg1;
21677
21678 wxPyEndAllowThreads(__tstate);
21679 if (PyErr_Occurred()) SWIG_fail;
21680 }
21681 resultobj = SWIG_Py_Void();
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 PyObject *resultobj = 0;
21690 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21691 wxString *result = 0 ;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 PyObject *swig_obj[1] ;
21695
21696 if (!args) SWIG_fail;
21697 swig_obj[0] = args;
21698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21699 if (!SWIG_IsOK(res1)) {
21700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21701 }
21702 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21703 {
21704 PyThreadState* __tstate = wxPyBeginAllowThreads();
21705 {
21706 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21707 result = (wxString *) &_result_ref;
21708 }
21709 wxPyEndAllowThreads(__tstate);
21710 if (PyErr_Occurred()) SWIG_fail;
21711 }
21712 {
21713 #if wxUSE_UNICODE
21714 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21715 #else
21716 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21717 #endif
21718 }
21719 return resultobj;
21720 fail:
21721 return NULL;
21722 }
21723
21724
21725 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21726 PyObject *obj;
21727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21728 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21729 return SWIG_Py_Void();
21730 }
21731
21732 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 return SWIG_Python_InitShadowInstance(args);
21734 }
21735
21736 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj = 0;
21738 wxString *arg1 = 0 ;
21739 wxString result;
21740 bool temp1 = false ;
21741 PyObject * obj0 = 0 ;
21742 char * kwnames[] = {
21743 (char *) "sz", NULL
21744 };
21745
21746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21747 {
21748 arg1 = wxString_in_helper(obj0);
21749 if (arg1 == NULL) SWIG_fail;
21750 temp1 = true;
21751 }
21752 {
21753 PyThreadState* __tstate = wxPyBeginAllowThreads();
21754 result = wxExpandEnvVars((wxString const &)*arg1);
21755 wxPyEndAllowThreads(__tstate);
21756 if (PyErr_Occurred()) SWIG_fail;
21757 }
21758 {
21759 #if wxUSE_UNICODE
21760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21761 #else
21762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21763 #endif
21764 }
21765 {
21766 if (temp1)
21767 delete arg1;
21768 }
21769 return resultobj;
21770 fail:
21771 {
21772 if (temp1)
21773 delete arg1;
21774 }
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21780 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21781 return 1;
21782 }
21783
21784
21785 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21786 PyObject *pyobj = 0;
21787
21788 {
21789 #if wxUSE_UNICODE
21790 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21791 #else
21792 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21793 #endif
21794 }
21795 return pyobj;
21796 }
21797
21798
21799 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21800 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21801 return 1;
21802 }
21803
21804
21805 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21806 PyObject *pyobj = 0;
21807
21808 {
21809 #if wxUSE_UNICODE
21810 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21811 #else
21812 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21813 #endif
21814 }
21815 return pyobj;
21816 }
21817
21818
21819 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21820 PyObject *resultobj = 0;
21821 wxDateTime::Country arg1 ;
21822 int val1 ;
21823 int ecode1 = 0 ;
21824 PyObject * obj0 = 0 ;
21825 char * kwnames[] = {
21826 (char *) "country", NULL
21827 };
21828
21829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21830 ecode1 = SWIG_AsVal_int(obj0, &val1);
21831 if (!SWIG_IsOK(ecode1)) {
21832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21833 }
21834 arg1 = static_cast< wxDateTime::Country >(val1);
21835 {
21836 PyThreadState* __tstate = wxPyBeginAllowThreads();
21837 wxDateTime::SetCountry(arg1);
21838 wxPyEndAllowThreads(__tstate);
21839 if (PyErr_Occurred()) SWIG_fail;
21840 }
21841 resultobj = SWIG_Py_Void();
21842 return resultobj;
21843 fail:
21844 return NULL;
21845 }
21846
21847
21848 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21849 PyObject *resultobj = 0;
21850 wxDateTime::Country result;
21851
21852 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21853 {
21854 PyThreadState* __tstate = wxPyBeginAllowThreads();
21855 result = (wxDateTime::Country)wxDateTime::GetCountry();
21856 wxPyEndAllowThreads(__tstate);
21857 if (PyErr_Occurred()) SWIG_fail;
21858 }
21859 resultobj = SWIG_From_int(static_cast< int >(result));
21860 return resultobj;
21861 fail:
21862 return NULL;
21863 }
21864
21865
21866 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21867 PyObject *resultobj = 0;
21868 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21869 bool result;
21870 int val1 ;
21871 int ecode1 = 0 ;
21872 PyObject * obj0 = 0 ;
21873 char * kwnames[] = {
21874 (char *) "country", NULL
21875 };
21876
21877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21878 if (obj0) {
21879 ecode1 = SWIG_AsVal_int(obj0, &val1);
21880 if (!SWIG_IsOK(ecode1)) {
21881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21882 }
21883 arg1 = static_cast< wxDateTime::Country >(val1);
21884 }
21885 {
21886 PyThreadState* __tstate = wxPyBeginAllowThreads();
21887 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21888 wxPyEndAllowThreads(__tstate);
21889 if (PyErr_Occurred()) SWIG_fail;
21890 }
21891 {
21892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21893 }
21894 return resultobj;
21895 fail:
21896 return NULL;
21897 }
21898
21899
21900 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21901 PyObject *resultobj = 0;
21902 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21903 int result;
21904 int val1 ;
21905 int ecode1 = 0 ;
21906 PyObject * obj0 = 0 ;
21907 char * kwnames[] = {
21908 (char *) "cal", NULL
21909 };
21910
21911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21912 if (obj0) {
21913 ecode1 = SWIG_AsVal_int(obj0, &val1);
21914 if (!SWIG_IsOK(ecode1)) {
21915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21916 }
21917 arg1 = static_cast< wxDateTime::Calendar >(val1);
21918 }
21919 {
21920 PyThreadState* __tstate = wxPyBeginAllowThreads();
21921 result = (int)wxDateTime::GetCurrentYear(arg1);
21922 wxPyEndAllowThreads(__tstate);
21923 if (PyErr_Occurred()) SWIG_fail;
21924 }
21925 resultobj = SWIG_From_int(static_cast< int >(result));
21926 return resultobj;
21927 fail:
21928 return NULL;
21929 }
21930
21931
21932 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21933 PyObject *resultobj = 0;
21934 int arg1 ;
21935 int result;
21936 int val1 ;
21937 int ecode1 = 0 ;
21938 PyObject * obj0 = 0 ;
21939 char * kwnames[] = {
21940 (char *) "year", NULL
21941 };
21942
21943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21944 ecode1 = SWIG_AsVal_int(obj0, &val1);
21945 if (!SWIG_IsOK(ecode1)) {
21946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21947 }
21948 arg1 = static_cast< int >(val1);
21949 {
21950 PyThreadState* __tstate = wxPyBeginAllowThreads();
21951 result = (int)wxDateTime::ConvertYearToBC(arg1);
21952 wxPyEndAllowThreads(__tstate);
21953 if (PyErr_Occurred()) SWIG_fail;
21954 }
21955 resultobj = SWIG_From_int(static_cast< int >(result));
21956 return resultobj;
21957 fail:
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj = 0;
21964 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21965 wxDateTime::Month result;
21966 int val1 ;
21967 int ecode1 = 0 ;
21968 PyObject * obj0 = 0 ;
21969 char * kwnames[] = {
21970 (char *) "cal", NULL
21971 };
21972
21973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21974 if (obj0) {
21975 ecode1 = SWIG_AsVal_int(obj0, &val1);
21976 if (!SWIG_IsOK(ecode1)) {
21977 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21978 }
21979 arg1 = static_cast< wxDateTime::Calendar >(val1);
21980 }
21981 {
21982 PyThreadState* __tstate = wxPyBeginAllowThreads();
21983 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
21984 wxPyEndAllowThreads(__tstate);
21985 if (PyErr_Occurred()) SWIG_fail;
21986 }
21987 resultobj = SWIG_From_int(static_cast< int >(result));
21988 return resultobj;
21989 fail:
21990 return NULL;
21991 }
21992
21993
21994 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21995 PyObject *resultobj = 0;
21996 int arg1 = (int) wxDateTime::Inv_Year ;
21997 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21998 bool result;
21999 int val1 ;
22000 int ecode1 = 0 ;
22001 int val2 ;
22002 int ecode2 = 0 ;
22003 PyObject * obj0 = 0 ;
22004 PyObject * obj1 = 0 ;
22005 char * kwnames[] = {
22006 (char *) "year",(char *) "cal", NULL
22007 };
22008
22009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22010 if (obj0) {
22011 ecode1 = SWIG_AsVal_int(obj0, &val1);
22012 if (!SWIG_IsOK(ecode1)) {
22013 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22014 }
22015 arg1 = static_cast< int >(val1);
22016 }
22017 if (obj1) {
22018 ecode2 = SWIG_AsVal_int(obj1, &val2);
22019 if (!SWIG_IsOK(ecode2)) {
22020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22021 }
22022 arg2 = static_cast< wxDateTime::Calendar >(val2);
22023 }
22024 {
22025 PyThreadState* __tstate = wxPyBeginAllowThreads();
22026 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22027 wxPyEndAllowThreads(__tstate);
22028 if (PyErr_Occurred()) SWIG_fail;
22029 }
22030 {
22031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22032 }
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22040 PyObject *resultobj = 0;
22041 int arg1 = (int) wxDateTime::Inv_Year ;
22042 int result;
22043 int val1 ;
22044 int ecode1 = 0 ;
22045 PyObject * obj0 = 0 ;
22046 char * kwnames[] = {
22047 (char *) "year", NULL
22048 };
22049
22050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22051 if (obj0) {
22052 ecode1 = SWIG_AsVal_int(obj0, &val1);
22053 if (!SWIG_IsOK(ecode1)) {
22054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22055 }
22056 arg1 = static_cast< int >(val1);
22057 }
22058 {
22059 PyThreadState* __tstate = wxPyBeginAllowThreads();
22060 result = (int)wxDateTime::GetCentury(arg1);
22061 wxPyEndAllowThreads(__tstate);
22062 if (PyErr_Occurred()) SWIG_fail;
22063 }
22064 resultobj = SWIG_From_int(static_cast< int >(result));
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22072 PyObject *resultobj = 0;
22073 int arg1 ;
22074 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22075 int result;
22076 int val1 ;
22077 int ecode1 = 0 ;
22078 int val2 ;
22079 int ecode2 = 0 ;
22080 PyObject * obj0 = 0 ;
22081 PyObject * obj1 = 0 ;
22082 char * kwnames[] = {
22083 (char *) "year",(char *) "cal", NULL
22084 };
22085
22086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22087 ecode1 = SWIG_AsVal_int(obj0, &val1);
22088 if (!SWIG_IsOK(ecode1)) {
22089 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22090 }
22091 arg1 = static_cast< int >(val1);
22092 if (obj1) {
22093 ecode2 = SWIG_AsVal_int(obj1, &val2);
22094 if (!SWIG_IsOK(ecode2)) {
22095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22096 }
22097 arg2 = static_cast< wxDateTime::Calendar >(val2);
22098 }
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 resultobj = SWIG_From_int(static_cast< int >(result));
22106 return resultobj;
22107 fail:
22108 return NULL;
22109 }
22110
22111
22112 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22113 PyObject *resultobj = 0;
22114 wxDateTime::Month arg1 ;
22115 int arg2 = (int) wxDateTime::Inv_Year ;
22116 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22117 int result;
22118 int val1 ;
22119 int ecode1 = 0 ;
22120 int val2 ;
22121 int ecode2 = 0 ;
22122 int val3 ;
22123 int ecode3 = 0 ;
22124 PyObject * obj0 = 0 ;
22125 PyObject * obj1 = 0 ;
22126 PyObject * obj2 = 0 ;
22127 char * kwnames[] = {
22128 (char *) "month",(char *) "year",(char *) "cal", NULL
22129 };
22130
22131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22132 ecode1 = SWIG_AsVal_int(obj0, &val1);
22133 if (!SWIG_IsOK(ecode1)) {
22134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22135 }
22136 arg1 = static_cast< wxDateTime::Month >(val1);
22137 if (obj1) {
22138 ecode2 = SWIG_AsVal_int(obj1, &val2);
22139 if (!SWIG_IsOK(ecode2)) {
22140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22141 }
22142 arg2 = static_cast< int >(val2);
22143 }
22144 if (obj2) {
22145 ecode3 = SWIG_AsVal_int(obj2, &val3);
22146 if (!SWIG_IsOK(ecode3)) {
22147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22148 }
22149 arg3 = static_cast< wxDateTime::Calendar >(val3);
22150 }
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 resultobj = SWIG_From_int(static_cast< int >(result));
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22165 PyObject *resultobj = 0;
22166 wxDateTime::Month arg1 ;
22167 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22168 wxString result;
22169 int val1 ;
22170 int ecode1 = 0 ;
22171 int val2 ;
22172 int ecode2 = 0 ;
22173 PyObject * obj0 = 0 ;
22174 PyObject * obj1 = 0 ;
22175 char * kwnames[] = {
22176 (char *) "month",(char *) "flags", NULL
22177 };
22178
22179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22180 ecode1 = SWIG_AsVal_int(obj0, &val1);
22181 if (!SWIG_IsOK(ecode1)) {
22182 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22183 }
22184 arg1 = static_cast< wxDateTime::Month >(val1);
22185 if (obj1) {
22186 ecode2 = SWIG_AsVal_int(obj1, &val2);
22187 if (!SWIG_IsOK(ecode2)) {
22188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22189 }
22190 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22191 }
22192 {
22193 PyThreadState* __tstate = wxPyBeginAllowThreads();
22194 result = wxDateTime::GetMonthName(arg1,arg2);
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 {
22199 #if wxUSE_UNICODE
22200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22201 #else
22202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22203 #endif
22204 }
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22212 PyObject *resultobj = 0;
22213 wxDateTime::WeekDay arg1 ;
22214 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22215 wxString result;
22216 int val1 ;
22217 int ecode1 = 0 ;
22218 int val2 ;
22219 int ecode2 = 0 ;
22220 PyObject * obj0 = 0 ;
22221 PyObject * obj1 = 0 ;
22222 char * kwnames[] = {
22223 (char *) "weekday",(char *) "flags", NULL
22224 };
22225
22226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22227 ecode1 = SWIG_AsVal_int(obj0, &val1);
22228 if (!SWIG_IsOK(ecode1)) {
22229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22230 }
22231 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22232 if (obj1) {
22233 ecode2 = SWIG_AsVal_int(obj1, &val2);
22234 if (!SWIG_IsOK(ecode2)) {
22235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22236 }
22237 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22238 }
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = wxDateTime::GetWeekDayName(arg1,arg2);
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 {
22246 #if wxUSE_UNICODE
22247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22248 #else
22249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22250 #endif
22251 }
22252 return resultobj;
22253 fail:
22254 return NULL;
22255 }
22256
22257
22258 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22259 PyObject *resultobj = 0;
22260 PyObject *result = 0 ;
22261
22262 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 result = (PyObject *)wxDateTime_GetAmPmStrings();
22266 wxPyEndAllowThreads(__tstate);
22267 if (PyErr_Occurred()) SWIG_fail;
22268 }
22269 resultobj = result;
22270 return resultobj;
22271 fail:
22272 return NULL;
22273 }
22274
22275
22276 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22277 PyObject *resultobj = 0;
22278 int arg1 = (int) wxDateTime::Inv_Year ;
22279 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22280 bool result;
22281 int val1 ;
22282 int ecode1 = 0 ;
22283 int val2 ;
22284 int ecode2 = 0 ;
22285 PyObject * obj0 = 0 ;
22286 PyObject * obj1 = 0 ;
22287 char * kwnames[] = {
22288 (char *) "year",(char *) "country", NULL
22289 };
22290
22291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22292 if (obj0) {
22293 ecode1 = SWIG_AsVal_int(obj0, &val1);
22294 if (!SWIG_IsOK(ecode1)) {
22295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22296 }
22297 arg1 = static_cast< int >(val1);
22298 }
22299 if (obj1) {
22300 ecode2 = SWIG_AsVal_int(obj1, &val2);
22301 if (!SWIG_IsOK(ecode2)) {
22302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22303 }
22304 arg2 = static_cast< wxDateTime::Country >(val2);
22305 }
22306 {
22307 PyThreadState* __tstate = wxPyBeginAllowThreads();
22308 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22309 wxPyEndAllowThreads(__tstate);
22310 if (PyErr_Occurred()) SWIG_fail;
22311 }
22312 {
22313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22314 }
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22322 PyObject *resultobj = 0;
22323 int arg1 = (int) wxDateTime::Inv_Year ;
22324 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22325 wxDateTime result;
22326 int val1 ;
22327 int ecode1 = 0 ;
22328 int val2 ;
22329 int ecode2 = 0 ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 char * kwnames[] = {
22333 (char *) "year",(char *) "country", NULL
22334 };
22335
22336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22337 if (obj0) {
22338 ecode1 = SWIG_AsVal_int(obj0, &val1);
22339 if (!SWIG_IsOK(ecode1)) {
22340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22341 }
22342 arg1 = static_cast< int >(val1);
22343 }
22344 if (obj1) {
22345 ecode2 = SWIG_AsVal_int(obj1, &val2);
22346 if (!SWIG_IsOK(ecode2)) {
22347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22348 }
22349 arg2 = static_cast< wxDateTime::Country >(val2);
22350 }
22351 {
22352 PyThreadState* __tstate = wxPyBeginAllowThreads();
22353 result = wxDateTime::GetBeginDST(arg1,arg2);
22354 wxPyEndAllowThreads(__tstate);
22355 if (PyErr_Occurred()) SWIG_fail;
22356 }
22357 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22358 return resultobj;
22359 fail:
22360 return NULL;
22361 }
22362
22363
22364 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22365 PyObject *resultobj = 0;
22366 int arg1 = (int) wxDateTime::Inv_Year ;
22367 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22368 wxDateTime result;
22369 int val1 ;
22370 int ecode1 = 0 ;
22371 int val2 ;
22372 int ecode2 = 0 ;
22373 PyObject * obj0 = 0 ;
22374 PyObject * obj1 = 0 ;
22375 char * kwnames[] = {
22376 (char *) "year",(char *) "country", NULL
22377 };
22378
22379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22380 if (obj0) {
22381 ecode1 = SWIG_AsVal_int(obj0, &val1);
22382 if (!SWIG_IsOK(ecode1)) {
22383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22384 }
22385 arg1 = static_cast< int >(val1);
22386 }
22387 if (obj1) {
22388 ecode2 = SWIG_AsVal_int(obj1, &val2);
22389 if (!SWIG_IsOK(ecode2)) {
22390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22391 }
22392 arg2 = static_cast< wxDateTime::Country >(val2);
22393 }
22394 {
22395 PyThreadState* __tstate = wxPyBeginAllowThreads();
22396 result = wxDateTime::GetEndDST(arg1,arg2);
22397 wxPyEndAllowThreads(__tstate);
22398 if (PyErr_Occurred()) SWIG_fail;
22399 }
22400 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22408 PyObject *resultobj = 0;
22409 wxDateTime result;
22410
22411 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22412 {
22413 PyThreadState* __tstate = wxPyBeginAllowThreads();
22414 result = wxDateTime::Now();
22415 wxPyEndAllowThreads(__tstate);
22416 if (PyErr_Occurred()) SWIG_fail;
22417 }
22418 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22419 return resultobj;
22420 fail:
22421 return NULL;
22422 }
22423
22424
22425 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22426 PyObject *resultobj = 0;
22427 wxDateTime result;
22428
22429 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22430 {
22431 PyThreadState* __tstate = wxPyBeginAllowThreads();
22432 result = wxDateTime::UNow();
22433 wxPyEndAllowThreads(__tstate);
22434 if (PyErr_Occurred()) SWIG_fail;
22435 }
22436 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22437 return resultobj;
22438 fail:
22439 return NULL;
22440 }
22441
22442
22443 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22444 PyObject *resultobj = 0;
22445 wxDateTime result;
22446
22447 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = wxDateTime::Today();
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22462 PyObject *resultobj = 0;
22463 wxDateTime *result = 0 ;
22464
22465 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22466 {
22467 PyThreadState* __tstate = wxPyBeginAllowThreads();
22468 result = (wxDateTime *)new wxDateTime();
22469 wxPyEndAllowThreads(__tstate);
22470 if (PyErr_Occurred()) SWIG_fail;
22471 }
22472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22480 PyObject *resultobj = 0;
22481 time_t arg1 ;
22482 wxDateTime *result = 0 ;
22483 unsigned int val1 ;
22484 int ecode1 = 0 ;
22485 PyObject * obj0 = 0 ;
22486 char * kwnames[] = {
22487 (char *) "timet", NULL
22488 };
22489
22490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22491 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22492 if (!SWIG_IsOK(ecode1)) {
22493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22494 }
22495 arg1 = static_cast< time_t >(val1);
22496 {
22497 PyThreadState* __tstate = wxPyBeginAllowThreads();
22498 result = (wxDateTime *)new wxDateTime(arg1);
22499 wxPyEndAllowThreads(__tstate);
22500 if (PyErr_Occurred()) SWIG_fail;
22501 }
22502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22510 PyObject *resultobj = 0;
22511 double arg1 ;
22512 wxDateTime *result = 0 ;
22513 double val1 ;
22514 int ecode1 = 0 ;
22515 PyObject * obj0 = 0 ;
22516 char * kwnames[] = {
22517 (char *) "jdn", NULL
22518 };
22519
22520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22521 ecode1 = SWIG_AsVal_double(obj0, &val1);
22522 if (!SWIG_IsOK(ecode1)) {
22523 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22524 }
22525 arg1 = static_cast< double >(val1);
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 result = (wxDateTime *)new wxDateTime(arg1);
22529 wxPyEndAllowThreads(__tstate);
22530 if (PyErr_Occurred()) SWIG_fail;
22531 }
22532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22533 return resultobj;
22534 fail:
22535 return NULL;
22536 }
22537
22538
22539 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22540 PyObject *resultobj = 0;
22541 int arg1 ;
22542 int arg2 = (int) 0 ;
22543 int arg3 = (int) 0 ;
22544 int arg4 = (int) 0 ;
22545 wxDateTime *result = 0 ;
22546 int val1 ;
22547 int ecode1 = 0 ;
22548 int val2 ;
22549 int ecode2 = 0 ;
22550 int val3 ;
22551 int ecode3 = 0 ;
22552 int val4 ;
22553 int ecode4 = 0 ;
22554 PyObject * obj0 = 0 ;
22555 PyObject * obj1 = 0 ;
22556 PyObject * obj2 = 0 ;
22557 PyObject * obj3 = 0 ;
22558 char * kwnames[] = {
22559 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22560 };
22561
22562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22563 ecode1 = SWIG_AsVal_int(obj0, &val1);
22564 if (!SWIG_IsOK(ecode1)) {
22565 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22566 }
22567 arg1 = static_cast< int >(val1);
22568 if (obj1) {
22569 ecode2 = SWIG_AsVal_int(obj1, &val2);
22570 if (!SWIG_IsOK(ecode2)) {
22571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22572 }
22573 arg2 = static_cast< int >(val2);
22574 }
22575 if (obj2) {
22576 ecode3 = SWIG_AsVal_int(obj2, &val3);
22577 if (!SWIG_IsOK(ecode3)) {
22578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22579 }
22580 arg3 = static_cast< int >(val3);
22581 }
22582 if (obj3) {
22583 ecode4 = SWIG_AsVal_int(obj3, &val4);
22584 if (!SWIG_IsOK(ecode4)) {
22585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22586 }
22587 arg4 = static_cast< int >(val4);
22588 }
22589 {
22590 PyThreadState* __tstate = wxPyBeginAllowThreads();
22591 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22592 wxPyEndAllowThreads(__tstate);
22593 if (PyErr_Occurred()) SWIG_fail;
22594 }
22595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22596 return resultobj;
22597 fail:
22598 return NULL;
22599 }
22600
22601
22602 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22603 PyObject *resultobj = 0;
22604 int arg1 ;
22605 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22606 int arg3 = (int) wxDateTime::Inv_Year ;
22607 int arg4 = (int) 0 ;
22608 int arg5 = (int) 0 ;
22609 int arg6 = (int) 0 ;
22610 int arg7 = (int) 0 ;
22611 wxDateTime *result = 0 ;
22612 int val1 ;
22613 int ecode1 = 0 ;
22614 int val2 ;
22615 int ecode2 = 0 ;
22616 int val3 ;
22617 int ecode3 = 0 ;
22618 int val4 ;
22619 int ecode4 = 0 ;
22620 int val5 ;
22621 int ecode5 = 0 ;
22622 int val6 ;
22623 int ecode6 = 0 ;
22624 int val7 ;
22625 int ecode7 = 0 ;
22626 PyObject * obj0 = 0 ;
22627 PyObject * obj1 = 0 ;
22628 PyObject * obj2 = 0 ;
22629 PyObject * obj3 = 0 ;
22630 PyObject * obj4 = 0 ;
22631 PyObject * obj5 = 0 ;
22632 PyObject * obj6 = 0 ;
22633 char * kwnames[] = {
22634 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22635 };
22636
22637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22638 ecode1 = SWIG_AsVal_int(obj0, &val1);
22639 if (!SWIG_IsOK(ecode1)) {
22640 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22641 }
22642 arg1 = static_cast< int >(val1);
22643 if (obj1) {
22644 ecode2 = SWIG_AsVal_int(obj1, &val2);
22645 if (!SWIG_IsOK(ecode2)) {
22646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22647 }
22648 arg2 = static_cast< wxDateTime::Month >(val2);
22649 }
22650 if (obj2) {
22651 ecode3 = SWIG_AsVal_int(obj2, &val3);
22652 if (!SWIG_IsOK(ecode3)) {
22653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22654 }
22655 arg3 = static_cast< int >(val3);
22656 }
22657 if (obj3) {
22658 ecode4 = SWIG_AsVal_int(obj3, &val4);
22659 if (!SWIG_IsOK(ecode4)) {
22660 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22661 }
22662 arg4 = static_cast< int >(val4);
22663 }
22664 if (obj4) {
22665 ecode5 = SWIG_AsVal_int(obj4, &val5);
22666 if (!SWIG_IsOK(ecode5)) {
22667 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22668 }
22669 arg5 = static_cast< int >(val5);
22670 }
22671 if (obj5) {
22672 ecode6 = SWIG_AsVal_int(obj5, &val6);
22673 if (!SWIG_IsOK(ecode6)) {
22674 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22675 }
22676 arg6 = static_cast< int >(val6);
22677 }
22678 if (obj6) {
22679 ecode7 = SWIG_AsVal_int(obj6, &val7);
22680 if (!SWIG_IsOK(ecode7)) {
22681 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22682 }
22683 arg7 = static_cast< int >(val7);
22684 }
22685 {
22686 PyThreadState* __tstate = wxPyBeginAllowThreads();
22687 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22688 wxPyEndAllowThreads(__tstate);
22689 if (PyErr_Occurred()) SWIG_fail;
22690 }
22691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22692 return resultobj;
22693 fail:
22694 return NULL;
22695 }
22696
22697
22698 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22699 PyObject *resultobj = 0;
22700 wxDateTime *arg1 = 0 ;
22701 wxDateTime *result = 0 ;
22702 void *argp1 = 0 ;
22703 int res1 = 0 ;
22704 PyObject * obj0 = 0 ;
22705 char * kwnames[] = {
22706 (char *) "date", NULL
22707 };
22708
22709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22710 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22711 if (!SWIG_IsOK(res1)) {
22712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22713 }
22714 if (!argp1) {
22715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22716 }
22717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22718 {
22719 PyThreadState* __tstate = wxPyBeginAllowThreads();
22720 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22721 wxPyEndAllowThreads(__tstate);
22722 if (PyErr_Occurred()) SWIG_fail;
22723 }
22724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22725 return resultobj;
22726 fail:
22727 return NULL;
22728 }
22729
22730
22731 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22732 PyObject *resultobj = 0;
22733 wxDateTime *arg1 = (wxDateTime *) 0 ;
22734 void *argp1 = 0 ;
22735 int res1 = 0 ;
22736 PyObject *swig_obj[1] ;
22737
22738 if (!args) SWIG_fail;
22739 swig_obj[0] = args;
22740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22741 if (!SWIG_IsOK(res1)) {
22742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22743 }
22744 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22745 {
22746 PyThreadState* __tstate = wxPyBeginAllowThreads();
22747 delete arg1;
22748
22749 wxPyEndAllowThreads(__tstate);
22750 if (PyErr_Occurred()) SWIG_fail;
22751 }
22752 resultobj = SWIG_Py_Void();
22753 return resultobj;
22754 fail:
22755 return NULL;
22756 }
22757
22758
22759 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22760 PyObject *resultobj = 0;
22761 wxDateTime *arg1 = (wxDateTime *) 0 ;
22762 wxDateTime *result = 0 ;
22763 void *argp1 = 0 ;
22764 int res1 = 0 ;
22765 PyObject *swig_obj[1] ;
22766
22767 if (!args) SWIG_fail;
22768 swig_obj[0] = args;
22769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22770 if (!SWIG_IsOK(res1)) {
22771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22772 }
22773 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22774 {
22775 PyThreadState* __tstate = wxPyBeginAllowThreads();
22776 {
22777 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22778 result = (wxDateTime *) &_result_ref;
22779 }
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22791 PyObject *resultobj = 0;
22792 wxDateTime *arg1 = (wxDateTime *) 0 ;
22793 time_t arg2 ;
22794 wxDateTime *result = 0 ;
22795 void *argp1 = 0 ;
22796 int res1 = 0 ;
22797 unsigned int val2 ;
22798 int ecode2 = 0 ;
22799 PyObject * obj0 = 0 ;
22800 PyObject * obj1 = 0 ;
22801 char * kwnames[] = {
22802 (char *) "self",(char *) "timet", NULL
22803 };
22804
22805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22807 if (!SWIG_IsOK(res1)) {
22808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22809 }
22810 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22811 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22812 if (!SWIG_IsOK(ecode2)) {
22813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22814 }
22815 arg2 = static_cast< time_t >(val2);
22816 {
22817 PyThreadState* __tstate = wxPyBeginAllowThreads();
22818 {
22819 wxDateTime &_result_ref = (arg1)->Set(arg2);
22820 result = (wxDateTime *) &_result_ref;
22821 }
22822 wxPyEndAllowThreads(__tstate);
22823 if (PyErr_Occurred()) SWIG_fail;
22824 }
22825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22826 return resultobj;
22827 fail:
22828 return NULL;
22829 }
22830
22831
22832 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22833 PyObject *resultobj = 0;
22834 wxDateTime *arg1 = (wxDateTime *) 0 ;
22835 double arg2 ;
22836 wxDateTime *result = 0 ;
22837 void *argp1 = 0 ;
22838 int res1 = 0 ;
22839 double val2 ;
22840 int ecode2 = 0 ;
22841 PyObject * obj0 = 0 ;
22842 PyObject * obj1 = 0 ;
22843 char * kwnames[] = {
22844 (char *) "self",(char *) "jdn", NULL
22845 };
22846
22847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22849 if (!SWIG_IsOK(res1)) {
22850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22851 }
22852 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22853 ecode2 = SWIG_AsVal_double(obj1, &val2);
22854 if (!SWIG_IsOK(ecode2)) {
22855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22856 }
22857 arg2 = static_cast< double >(val2);
22858 {
22859 PyThreadState* __tstate = wxPyBeginAllowThreads();
22860 {
22861 wxDateTime &_result_ref = (arg1)->Set(arg2);
22862 result = (wxDateTime *) &_result_ref;
22863 }
22864 wxPyEndAllowThreads(__tstate);
22865 if (PyErr_Occurred()) SWIG_fail;
22866 }
22867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22868 return resultobj;
22869 fail:
22870 return NULL;
22871 }
22872
22873
22874 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22875 PyObject *resultobj = 0;
22876 wxDateTime *arg1 = (wxDateTime *) 0 ;
22877 int arg2 ;
22878 int arg3 = (int) 0 ;
22879 int arg4 = (int) 0 ;
22880 int arg5 = (int) 0 ;
22881 wxDateTime *result = 0 ;
22882 void *argp1 = 0 ;
22883 int res1 = 0 ;
22884 int val2 ;
22885 int ecode2 = 0 ;
22886 int val3 ;
22887 int ecode3 = 0 ;
22888 int val4 ;
22889 int ecode4 = 0 ;
22890 int val5 ;
22891 int ecode5 = 0 ;
22892 PyObject * obj0 = 0 ;
22893 PyObject * obj1 = 0 ;
22894 PyObject * obj2 = 0 ;
22895 PyObject * obj3 = 0 ;
22896 PyObject * obj4 = 0 ;
22897 char * kwnames[] = {
22898 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22899 };
22900
22901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22903 if (!SWIG_IsOK(res1)) {
22904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22905 }
22906 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22907 ecode2 = SWIG_AsVal_int(obj1, &val2);
22908 if (!SWIG_IsOK(ecode2)) {
22909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22910 }
22911 arg2 = static_cast< int >(val2);
22912 if (obj2) {
22913 ecode3 = SWIG_AsVal_int(obj2, &val3);
22914 if (!SWIG_IsOK(ecode3)) {
22915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22916 }
22917 arg3 = static_cast< int >(val3);
22918 }
22919 if (obj3) {
22920 ecode4 = SWIG_AsVal_int(obj3, &val4);
22921 if (!SWIG_IsOK(ecode4)) {
22922 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22923 }
22924 arg4 = static_cast< int >(val4);
22925 }
22926 if (obj4) {
22927 ecode5 = SWIG_AsVal_int(obj4, &val5);
22928 if (!SWIG_IsOK(ecode5)) {
22929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22930 }
22931 arg5 = static_cast< int >(val5);
22932 }
22933 {
22934 PyThreadState* __tstate = wxPyBeginAllowThreads();
22935 {
22936 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22937 result = (wxDateTime *) &_result_ref;
22938 }
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22943 return resultobj;
22944 fail:
22945 return NULL;
22946 }
22947
22948
22949 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22950 PyObject *resultobj = 0;
22951 wxDateTime *arg1 = (wxDateTime *) 0 ;
22952 int arg2 ;
22953 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22954 int arg4 = (int) wxDateTime::Inv_Year ;
22955 int arg5 = (int) 0 ;
22956 int arg6 = (int) 0 ;
22957 int arg7 = (int) 0 ;
22958 int arg8 = (int) 0 ;
22959 wxDateTime *result = 0 ;
22960 void *argp1 = 0 ;
22961 int res1 = 0 ;
22962 int val2 ;
22963 int ecode2 = 0 ;
22964 int val3 ;
22965 int ecode3 = 0 ;
22966 int val4 ;
22967 int ecode4 = 0 ;
22968 int val5 ;
22969 int ecode5 = 0 ;
22970 int val6 ;
22971 int ecode6 = 0 ;
22972 int val7 ;
22973 int ecode7 = 0 ;
22974 int val8 ;
22975 int ecode8 = 0 ;
22976 PyObject * obj0 = 0 ;
22977 PyObject * obj1 = 0 ;
22978 PyObject * obj2 = 0 ;
22979 PyObject * obj3 = 0 ;
22980 PyObject * obj4 = 0 ;
22981 PyObject * obj5 = 0 ;
22982 PyObject * obj6 = 0 ;
22983 PyObject * obj7 = 0 ;
22984 char * kwnames[] = {
22985 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22986 };
22987
22988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22990 if (!SWIG_IsOK(res1)) {
22991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
22992 }
22993 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22994 ecode2 = SWIG_AsVal_int(obj1, &val2);
22995 if (!SWIG_IsOK(ecode2)) {
22996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
22997 }
22998 arg2 = static_cast< int >(val2);
22999 if (obj2) {
23000 ecode3 = SWIG_AsVal_int(obj2, &val3);
23001 if (!SWIG_IsOK(ecode3)) {
23002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23003 }
23004 arg3 = static_cast< wxDateTime::Month >(val3);
23005 }
23006 if (obj3) {
23007 ecode4 = SWIG_AsVal_int(obj3, &val4);
23008 if (!SWIG_IsOK(ecode4)) {
23009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23010 }
23011 arg4 = static_cast< int >(val4);
23012 }
23013 if (obj4) {
23014 ecode5 = SWIG_AsVal_int(obj4, &val5);
23015 if (!SWIG_IsOK(ecode5)) {
23016 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23017 }
23018 arg5 = static_cast< int >(val5);
23019 }
23020 if (obj5) {
23021 ecode6 = SWIG_AsVal_int(obj5, &val6);
23022 if (!SWIG_IsOK(ecode6)) {
23023 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23024 }
23025 arg6 = static_cast< int >(val6);
23026 }
23027 if (obj6) {
23028 ecode7 = SWIG_AsVal_int(obj6, &val7);
23029 if (!SWIG_IsOK(ecode7)) {
23030 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23031 }
23032 arg7 = static_cast< int >(val7);
23033 }
23034 if (obj7) {
23035 ecode8 = SWIG_AsVal_int(obj7, &val8);
23036 if (!SWIG_IsOK(ecode8)) {
23037 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23038 }
23039 arg8 = static_cast< int >(val8);
23040 }
23041 {
23042 PyThreadState* __tstate = wxPyBeginAllowThreads();
23043 {
23044 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23045 result = (wxDateTime *) &_result_ref;
23046 }
23047 wxPyEndAllowThreads(__tstate);
23048 if (PyErr_Occurred()) SWIG_fail;
23049 }
23050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23051 return resultobj;
23052 fail:
23053 return NULL;
23054 }
23055
23056
23057 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23058 PyObject *resultobj = 0;
23059 wxDateTime *arg1 = (wxDateTime *) 0 ;
23060 wxDateTime *result = 0 ;
23061 void *argp1 = 0 ;
23062 int res1 = 0 ;
23063 PyObject *swig_obj[1] ;
23064
23065 if (!args) SWIG_fail;
23066 swig_obj[0] = args;
23067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23068 if (!SWIG_IsOK(res1)) {
23069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23070 }
23071 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23072 {
23073 PyThreadState* __tstate = wxPyBeginAllowThreads();
23074 {
23075 wxDateTime &_result_ref = (arg1)->ResetTime();
23076 result = (wxDateTime *) &_result_ref;
23077 }
23078 wxPyEndAllowThreads(__tstate);
23079 if (PyErr_Occurred()) SWIG_fail;
23080 }
23081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23082 return resultobj;
23083 fail:
23084 return NULL;
23085 }
23086
23087
23088 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23089 PyObject *resultobj = 0;
23090 wxDateTime *arg1 = (wxDateTime *) 0 ;
23091 int arg2 ;
23092 wxDateTime *result = 0 ;
23093 void *argp1 = 0 ;
23094 int res1 = 0 ;
23095 int val2 ;
23096 int ecode2 = 0 ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 char * kwnames[] = {
23100 (char *) "self",(char *) "year", NULL
23101 };
23102
23103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23107 }
23108 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23109 ecode2 = SWIG_AsVal_int(obj1, &val2);
23110 if (!SWIG_IsOK(ecode2)) {
23111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23112 }
23113 arg2 = static_cast< int >(val2);
23114 {
23115 PyThreadState* __tstate = wxPyBeginAllowThreads();
23116 {
23117 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23118 result = (wxDateTime *) &_result_ref;
23119 }
23120 wxPyEndAllowThreads(__tstate);
23121 if (PyErr_Occurred()) SWIG_fail;
23122 }
23123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23124 return resultobj;
23125 fail:
23126 return NULL;
23127 }
23128
23129
23130 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23131 PyObject *resultobj = 0;
23132 wxDateTime *arg1 = (wxDateTime *) 0 ;
23133 wxDateTime::Month arg2 ;
23134 wxDateTime *result = 0 ;
23135 void *argp1 = 0 ;
23136 int res1 = 0 ;
23137 int val2 ;
23138 int ecode2 = 0 ;
23139 PyObject * obj0 = 0 ;
23140 PyObject * obj1 = 0 ;
23141 char * kwnames[] = {
23142 (char *) "self",(char *) "month", NULL
23143 };
23144
23145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23147 if (!SWIG_IsOK(res1)) {
23148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23149 }
23150 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23151 ecode2 = SWIG_AsVal_int(obj1, &val2);
23152 if (!SWIG_IsOK(ecode2)) {
23153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23154 }
23155 arg2 = static_cast< wxDateTime::Month >(val2);
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 {
23159 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23160 result = (wxDateTime *) &_result_ref;
23161 }
23162 wxPyEndAllowThreads(__tstate);
23163 if (PyErr_Occurred()) SWIG_fail;
23164 }
23165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23166 return resultobj;
23167 fail:
23168 return NULL;
23169 }
23170
23171
23172 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23173 PyObject *resultobj = 0;
23174 wxDateTime *arg1 = (wxDateTime *) 0 ;
23175 int arg2 ;
23176 wxDateTime *result = 0 ;
23177 void *argp1 = 0 ;
23178 int res1 = 0 ;
23179 int val2 ;
23180 int ecode2 = 0 ;
23181 PyObject * obj0 = 0 ;
23182 PyObject * obj1 = 0 ;
23183 char * kwnames[] = {
23184 (char *) "self",(char *) "day", NULL
23185 };
23186
23187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23189 if (!SWIG_IsOK(res1)) {
23190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23191 }
23192 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23193 ecode2 = SWIG_AsVal_int(obj1, &val2);
23194 if (!SWIG_IsOK(ecode2)) {
23195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23196 }
23197 arg2 = static_cast< int >(val2);
23198 {
23199 PyThreadState* __tstate = wxPyBeginAllowThreads();
23200 {
23201 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23202 result = (wxDateTime *) &_result_ref;
23203 }
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23215 PyObject *resultobj = 0;
23216 wxDateTime *arg1 = (wxDateTime *) 0 ;
23217 int arg2 ;
23218 wxDateTime *result = 0 ;
23219 void *argp1 = 0 ;
23220 int res1 = 0 ;
23221 int val2 ;
23222 int ecode2 = 0 ;
23223 PyObject * obj0 = 0 ;
23224 PyObject * obj1 = 0 ;
23225 char * kwnames[] = {
23226 (char *) "self",(char *) "hour", NULL
23227 };
23228
23229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23231 if (!SWIG_IsOK(res1)) {
23232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23233 }
23234 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23235 ecode2 = SWIG_AsVal_int(obj1, &val2);
23236 if (!SWIG_IsOK(ecode2)) {
23237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23238 }
23239 arg2 = static_cast< int >(val2);
23240 {
23241 PyThreadState* __tstate = wxPyBeginAllowThreads();
23242 {
23243 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23244 result = (wxDateTime *) &_result_ref;
23245 }
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj = 0;
23258 wxDateTime *arg1 = (wxDateTime *) 0 ;
23259 int arg2 ;
23260 wxDateTime *result = 0 ;
23261 void *argp1 = 0 ;
23262 int res1 = 0 ;
23263 int val2 ;
23264 int ecode2 = 0 ;
23265 PyObject * obj0 = 0 ;
23266 PyObject * obj1 = 0 ;
23267 char * kwnames[] = {
23268 (char *) "self",(char *) "minute", NULL
23269 };
23270
23271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23273 if (!SWIG_IsOK(res1)) {
23274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23275 }
23276 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23277 ecode2 = SWIG_AsVal_int(obj1, &val2);
23278 if (!SWIG_IsOK(ecode2)) {
23279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23280 }
23281 arg2 = static_cast< int >(val2);
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 {
23285 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23286 result = (wxDateTime *) &_result_ref;
23287 }
23288 wxPyEndAllowThreads(__tstate);
23289 if (PyErr_Occurred()) SWIG_fail;
23290 }
23291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23292 return resultobj;
23293 fail:
23294 return NULL;
23295 }
23296
23297
23298 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23299 PyObject *resultobj = 0;
23300 wxDateTime *arg1 = (wxDateTime *) 0 ;
23301 int arg2 ;
23302 wxDateTime *result = 0 ;
23303 void *argp1 = 0 ;
23304 int res1 = 0 ;
23305 int val2 ;
23306 int ecode2 = 0 ;
23307 PyObject * obj0 = 0 ;
23308 PyObject * obj1 = 0 ;
23309 char * kwnames[] = {
23310 (char *) "self",(char *) "second", NULL
23311 };
23312
23313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23315 if (!SWIG_IsOK(res1)) {
23316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23317 }
23318 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23319 ecode2 = SWIG_AsVal_int(obj1, &val2);
23320 if (!SWIG_IsOK(ecode2)) {
23321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23322 }
23323 arg2 = static_cast< int >(val2);
23324 {
23325 PyThreadState* __tstate = wxPyBeginAllowThreads();
23326 {
23327 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23328 result = (wxDateTime *) &_result_ref;
23329 }
23330 wxPyEndAllowThreads(__tstate);
23331 if (PyErr_Occurred()) SWIG_fail;
23332 }
23333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23341 PyObject *resultobj = 0;
23342 wxDateTime *arg1 = (wxDateTime *) 0 ;
23343 int arg2 ;
23344 wxDateTime *result = 0 ;
23345 void *argp1 = 0 ;
23346 int res1 = 0 ;
23347 int val2 ;
23348 int ecode2 = 0 ;
23349 PyObject * obj0 = 0 ;
23350 PyObject * obj1 = 0 ;
23351 char * kwnames[] = {
23352 (char *) "self",(char *) "millisecond", NULL
23353 };
23354
23355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23357 if (!SWIG_IsOK(res1)) {
23358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23359 }
23360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23361 ecode2 = SWIG_AsVal_int(obj1, &val2);
23362 if (!SWIG_IsOK(ecode2)) {
23363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23364 }
23365 arg2 = static_cast< int >(val2);
23366 {
23367 PyThreadState* __tstate = wxPyBeginAllowThreads();
23368 {
23369 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23370 result = (wxDateTime *) &_result_ref;
23371 }
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23376 return resultobj;
23377 fail:
23378 return NULL;
23379 }
23380
23381
23382 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23383 PyObject *resultobj = 0;
23384 wxDateTime *arg1 = (wxDateTime *) 0 ;
23385 wxDateTime::WeekDay arg2 ;
23386 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23387 wxDateTime *result = 0 ;
23388 void *argp1 = 0 ;
23389 int res1 = 0 ;
23390 int val2 ;
23391 int ecode2 = 0 ;
23392 int val3 ;
23393 int ecode3 = 0 ;
23394 PyObject * obj0 = 0 ;
23395 PyObject * obj1 = 0 ;
23396 PyObject * obj2 = 0 ;
23397 char * kwnames[] = {
23398 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23399 };
23400
23401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23403 if (!SWIG_IsOK(res1)) {
23404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23405 }
23406 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23407 ecode2 = SWIG_AsVal_int(obj1, &val2);
23408 if (!SWIG_IsOK(ecode2)) {
23409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23410 }
23411 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23412 if (obj2) {
23413 ecode3 = SWIG_AsVal_int(obj2, &val3);
23414 if (!SWIG_IsOK(ecode3)) {
23415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23416 }
23417 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23418 }
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 {
23422 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23423 result = (wxDateTime *) &_result_ref;
23424 }
23425 wxPyEndAllowThreads(__tstate);
23426 if (PyErr_Occurred()) SWIG_fail;
23427 }
23428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23429 return resultobj;
23430 fail:
23431 return NULL;
23432 }
23433
23434
23435 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23436 PyObject *resultobj = 0;
23437 wxDateTime *arg1 = (wxDateTime *) 0 ;
23438 wxDateTime::WeekDay arg2 ;
23439 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23440 wxDateTime result;
23441 void *argp1 = 0 ;
23442 int res1 = 0 ;
23443 int val2 ;
23444 int ecode2 = 0 ;
23445 int val3 ;
23446 int ecode3 = 0 ;
23447 PyObject * obj0 = 0 ;
23448 PyObject * obj1 = 0 ;
23449 PyObject * obj2 = 0 ;
23450 char * kwnames[] = {
23451 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23452 };
23453
23454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23456 if (!SWIG_IsOK(res1)) {
23457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23458 }
23459 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23460 ecode2 = SWIG_AsVal_int(obj1, &val2);
23461 if (!SWIG_IsOK(ecode2)) {
23462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23463 }
23464 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23465 if (obj2) {
23466 ecode3 = SWIG_AsVal_int(obj2, &val3);
23467 if (!SWIG_IsOK(ecode3)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23469 }
23470 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23471 }
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj = 0;
23487 wxDateTime *arg1 = (wxDateTime *) 0 ;
23488 wxDateTime::WeekDay arg2 ;
23489 wxDateTime *result = 0 ;
23490 void *argp1 = 0 ;
23491 int res1 = 0 ;
23492 int val2 ;
23493 int ecode2 = 0 ;
23494 PyObject * obj0 = 0 ;
23495 PyObject * obj1 = 0 ;
23496 char * kwnames[] = {
23497 (char *) "self",(char *) "weekday", NULL
23498 };
23499
23500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23502 if (!SWIG_IsOK(res1)) {
23503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23504 }
23505 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23506 ecode2 = SWIG_AsVal_int(obj1, &val2);
23507 if (!SWIG_IsOK(ecode2)) {
23508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23509 }
23510 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23511 {
23512 PyThreadState* __tstate = wxPyBeginAllowThreads();
23513 {
23514 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23515 result = (wxDateTime *) &_result_ref;
23516 }
23517 wxPyEndAllowThreads(__tstate);
23518 if (PyErr_Occurred()) SWIG_fail;
23519 }
23520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj = 0;
23529 wxDateTime *arg1 = (wxDateTime *) 0 ;
23530 wxDateTime::WeekDay arg2 ;
23531 wxDateTime result;
23532 void *argp1 = 0 ;
23533 int res1 = 0 ;
23534 int val2 ;
23535 int ecode2 = 0 ;
23536 PyObject * obj0 = 0 ;
23537 PyObject * obj1 = 0 ;
23538 char * kwnames[] = {
23539 (char *) "self",(char *) "weekday", NULL
23540 };
23541
23542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23544 if (!SWIG_IsOK(res1)) {
23545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23546 }
23547 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23548 ecode2 = SWIG_AsVal_int(obj1, &val2);
23549 if (!SWIG_IsOK(ecode2)) {
23550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23551 }
23552 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 result = (arg1)->GetNextWeekDay(arg2);
23556 wxPyEndAllowThreads(__tstate);
23557 if (PyErr_Occurred()) SWIG_fail;
23558 }
23559 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23567 PyObject *resultobj = 0;
23568 wxDateTime *arg1 = (wxDateTime *) 0 ;
23569 wxDateTime::WeekDay arg2 ;
23570 wxDateTime *result = 0 ;
23571 void *argp1 = 0 ;
23572 int res1 = 0 ;
23573 int val2 ;
23574 int ecode2 = 0 ;
23575 PyObject * obj0 = 0 ;
23576 PyObject * obj1 = 0 ;
23577 char * kwnames[] = {
23578 (char *) "self",(char *) "weekday", NULL
23579 };
23580
23581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23583 if (!SWIG_IsOK(res1)) {
23584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23585 }
23586 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23587 ecode2 = SWIG_AsVal_int(obj1, &val2);
23588 if (!SWIG_IsOK(ecode2)) {
23589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23590 }
23591 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23592 {
23593 PyThreadState* __tstate = wxPyBeginAllowThreads();
23594 {
23595 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23596 result = (wxDateTime *) &_result_ref;
23597 }
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23602 return resultobj;
23603 fail:
23604 return NULL;
23605 }
23606
23607
23608 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23609 PyObject *resultobj = 0;
23610 wxDateTime *arg1 = (wxDateTime *) 0 ;
23611 wxDateTime::WeekDay arg2 ;
23612 wxDateTime result;
23613 void *argp1 = 0 ;
23614 int res1 = 0 ;
23615 int val2 ;
23616 int ecode2 = 0 ;
23617 PyObject * obj0 = 0 ;
23618 PyObject * obj1 = 0 ;
23619 char * kwnames[] = {
23620 (char *) "self",(char *) "weekday", NULL
23621 };
23622
23623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23625 if (!SWIG_IsOK(res1)) {
23626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23627 }
23628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23629 ecode2 = SWIG_AsVal_int(obj1, &val2);
23630 if (!SWIG_IsOK(ecode2)) {
23631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23632 }
23633 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23634 {
23635 PyThreadState* __tstate = wxPyBeginAllowThreads();
23636 result = (arg1)->GetPrevWeekDay(arg2);
23637 wxPyEndAllowThreads(__tstate);
23638 if (PyErr_Occurred()) SWIG_fail;
23639 }
23640 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23648 PyObject *resultobj = 0;
23649 wxDateTime *arg1 = (wxDateTime *) 0 ;
23650 wxDateTime::WeekDay arg2 ;
23651 int arg3 = (int) 1 ;
23652 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23653 int arg5 = (int) wxDateTime::Inv_Year ;
23654 bool result;
23655 void *argp1 = 0 ;
23656 int res1 = 0 ;
23657 int val2 ;
23658 int ecode2 = 0 ;
23659 int val3 ;
23660 int ecode3 = 0 ;
23661 int val4 ;
23662 int ecode4 = 0 ;
23663 int val5 ;
23664 int ecode5 = 0 ;
23665 PyObject * obj0 = 0 ;
23666 PyObject * obj1 = 0 ;
23667 PyObject * obj2 = 0 ;
23668 PyObject * obj3 = 0 ;
23669 PyObject * obj4 = 0 ;
23670 char * kwnames[] = {
23671 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23672 };
23673
23674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23676 if (!SWIG_IsOK(res1)) {
23677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23678 }
23679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23680 ecode2 = SWIG_AsVal_int(obj1, &val2);
23681 if (!SWIG_IsOK(ecode2)) {
23682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23683 }
23684 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23685 if (obj2) {
23686 ecode3 = SWIG_AsVal_int(obj2, &val3);
23687 if (!SWIG_IsOK(ecode3)) {
23688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23689 }
23690 arg3 = static_cast< int >(val3);
23691 }
23692 if (obj3) {
23693 ecode4 = SWIG_AsVal_int(obj3, &val4);
23694 if (!SWIG_IsOK(ecode4)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23696 }
23697 arg4 = static_cast< wxDateTime::Month >(val4);
23698 }
23699 if (obj4) {
23700 ecode5 = SWIG_AsVal_int(obj4, &val5);
23701 if (!SWIG_IsOK(ecode5)) {
23702 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23703 }
23704 arg5 = static_cast< int >(val5);
23705 }
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 {
23713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23714 }
23715 return resultobj;
23716 fail:
23717 return NULL;
23718 }
23719
23720
23721 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23722 PyObject *resultobj = 0;
23723 wxDateTime *arg1 = (wxDateTime *) 0 ;
23724 wxDateTime::WeekDay arg2 ;
23725 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23726 int arg4 = (int) wxDateTime::Inv_Year ;
23727 bool result;
23728 void *argp1 = 0 ;
23729 int res1 = 0 ;
23730 int val2 ;
23731 int ecode2 = 0 ;
23732 int val3 ;
23733 int ecode3 = 0 ;
23734 int val4 ;
23735 int ecode4 = 0 ;
23736 PyObject * obj0 = 0 ;
23737 PyObject * obj1 = 0 ;
23738 PyObject * obj2 = 0 ;
23739 PyObject * obj3 = 0 ;
23740 char * kwnames[] = {
23741 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23742 };
23743
23744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23746 if (!SWIG_IsOK(res1)) {
23747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23748 }
23749 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23750 ecode2 = SWIG_AsVal_int(obj1, &val2);
23751 if (!SWIG_IsOK(ecode2)) {
23752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23753 }
23754 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23755 if (obj2) {
23756 ecode3 = SWIG_AsVal_int(obj2, &val3);
23757 if (!SWIG_IsOK(ecode3)) {
23758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23759 }
23760 arg3 = static_cast< wxDateTime::Month >(val3);
23761 }
23762 if (obj3) {
23763 ecode4 = SWIG_AsVal_int(obj3, &val4);
23764 if (!SWIG_IsOK(ecode4)) {
23765 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23766 }
23767 arg4 = static_cast< int >(val4);
23768 }
23769 {
23770 PyThreadState* __tstate = wxPyBeginAllowThreads();
23771 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23772 wxPyEndAllowThreads(__tstate);
23773 if (PyErr_Occurred()) SWIG_fail;
23774 }
23775 {
23776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23777 }
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23785 PyObject *resultobj = 0;
23786 wxDateTime *arg1 = (wxDateTime *) 0 ;
23787 wxDateTime::WeekDay arg2 ;
23788 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23789 int arg4 = (int) wxDateTime::Inv_Year ;
23790 wxDateTime result;
23791 void *argp1 = 0 ;
23792 int res1 = 0 ;
23793 int val2 ;
23794 int ecode2 = 0 ;
23795 int val3 ;
23796 int ecode3 = 0 ;
23797 int val4 ;
23798 int ecode4 = 0 ;
23799 PyObject * obj0 = 0 ;
23800 PyObject * obj1 = 0 ;
23801 PyObject * obj2 = 0 ;
23802 PyObject * obj3 = 0 ;
23803 char * kwnames[] = {
23804 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23805 };
23806
23807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23809 if (!SWIG_IsOK(res1)) {
23810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23811 }
23812 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23813 ecode2 = SWIG_AsVal_int(obj1, &val2);
23814 if (!SWIG_IsOK(ecode2)) {
23815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23816 }
23817 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23818 if (obj2) {
23819 ecode3 = SWIG_AsVal_int(obj2, &val3);
23820 if (!SWIG_IsOK(ecode3)) {
23821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23822 }
23823 arg3 = static_cast< wxDateTime::Month >(val3);
23824 }
23825 if (obj3) {
23826 ecode4 = SWIG_AsVal_int(obj3, &val4);
23827 if (!SWIG_IsOK(ecode4)) {
23828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23829 }
23830 arg4 = static_cast< int >(val4);
23831 }
23832 {
23833 PyThreadState* __tstate = wxPyBeginAllowThreads();
23834 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23835 wxPyEndAllowThreads(__tstate);
23836 if (PyErr_Occurred()) SWIG_fail;
23837 }
23838 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23839 return resultobj;
23840 fail:
23841 return NULL;
23842 }
23843
23844
23845 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23846 PyObject *resultobj = 0;
23847 wxDateTime *arg1 = (wxDateTime *) 0 ;
23848 int arg2 ;
23849 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23850 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23851 bool result;
23852 void *argp1 = 0 ;
23853 int res1 = 0 ;
23854 int val2 ;
23855 int ecode2 = 0 ;
23856 int val3 ;
23857 int ecode3 = 0 ;
23858 int val4 ;
23859 int ecode4 = 0 ;
23860 PyObject * obj0 = 0 ;
23861 PyObject * obj1 = 0 ;
23862 PyObject * obj2 = 0 ;
23863 PyObject * obj3 = 0 ;
23864 char * kwnames[] = {
23865 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23866 };
23867
23868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23870 if (!SWIG_IsOK(res1)) {
23871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23872 }
23873 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23874 ecode2 = SWIG_AsVal_int(obj1, &val2);
23875 if (!SWIG_IsOK(ecode2)) {
23876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23877 }
23878 arg2 = static_cast< int >(val2);
23879 if (obj2) {
23880 ecode3 = SWIG_AsVal_int(obj2, &val3);
23881 if (!SWIG_IsOK(ecode3)) {
23882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23883 }
23884 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23885 }
23886 if (obj3) {
23887 ecode4 = SWIG_AsVal_int(obj3, &val4);
23888 if (!SWIG_IsOK(ecode4)) {
23889 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23890 }
23891 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23892 }
23893 {
23894 PyThreadState* __tstate = wxPyBeginAllowThreads();
23895 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23896 wxPyEndAllowThreads(__tstate);
23897 if (PyErr_Occurred()) SWIG_fail;
23898 }
23899 {
23900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23901 }
23902 return resultobj;
23903 fail:
23904 return NULL;
23905 }
23906
23907
23908 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23909 PyObject *resultobj = 0;
23910 wxDateTime *arg1 = (wxDateTime *) 0 ;
23911 int arg2 ;
23912 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23913 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23914 wxDateTime result;
23915 void *argp1 = 0 ;
23916 int res1 = 0 ;
23917 int val2 ;
23918 int ecode2 = 0 ;
23919 int val3 ;
23920 int ecode3 = 0 ;
23921 int val4 ;
23922 int ecode4 = 0 ;
23923 PyObject * obj0 = 0 ;
23924 PyObject * obj1 = 0 ;
23925 PyObject * obj2 = 0 ;
23926 PyObject * obj3 = 0 ;
23927 char * kwnames[] = {
23928 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23929 };
23930
23931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23933 if (!SWIG_IsOK(res1)) {
23934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23935 }
23936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23937 ecode2 = SWIG_AsVal_int(obj1, &val2);
23938 if (!SWIG_IsOK(ecode2)) {
23939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23940 }
23941 arg2 = static_cast< int >(val2);
23942 if (obj2) {
23943 ecode3 = SWIG_AsVal_int(obj2, &val3);
23944 if (!SWIG_IsOK(ecode3)) {
23945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23946 }
23947 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23948 }
23949 if (obj3) {
23950 ecode4 = SWIG_AsVal_int(obj3, &val4);
23951 if (!SWIG_IsOK(ecode4)) {
23952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23953 }
23954 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23955 }
23956 {
23957 PyThreadState* __tstate = wxPyBeginAllowThreads();
23958 result = (arg1)->GetWeek(arg2,arg3,arg4);
23959 wxPyEndAllowThreads(__tstate);
23960 if (PyErr_Occurred()) SWIG_fail;
23961 }
23962 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23963 return resultobj;
23964 fail:
23965 return NULL;
23966 }
23967
23968
23969 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23970 PyObject *resultobj = 0;
23971 int arg1 ;
23972 int arg2 ;
23973 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23974 wxDateTime result;
23975 int val1 ;
23976 int ecode1 = 0 ;
23977 int val2 ;
23978 int ecode2 = 0 ;
23979 int val3 ;
23980 int ecode3 = 0 ;
23981 PyObject * obj0 = 0 ;
23982 PyObject * obj1 = 0 ;
23983 PyObject * obj2 = 0 ;
23984 char * kwnames[] = {
23985 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
23986 };
23987
23988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23989 ecode1 = SWIG_AsVal_int(obj0, &val1);
23990 if (!SWIG_IsOK(ecode1)) {
23991 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
23992 }
23993 arg1 = static_cast< int >(val1);
23994 ecode2 = SWIG_AsVal_int(obj1, &val2);
23995 if (!SWIG_IsOK(ecode2)) {
23996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
23997 }
23998 arg2 = static_cast< int >(val2);
23999 if (obj2) {
24000 ecode3 = SWIG_AsVal_int(obj2, &val3);
24001 if (!SWIG_IsOK(ecode3)) {
24002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24003 }
24004 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24005 }
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24020 PyObject *resultobj = 0;
24021 wxDateTime *arg1 = (wxDateTime *) 0 ;
24022 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24023 int arg3 = (int) wxDateTime::Inv_Year ;
24024 wxDateTime *result = 0 ;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 int val2 ;
24028 int ecode2 = 0 ;
24029 int val3 ;
24030 int ecode3 = 0 ;
24031 PyObject * obj0 = 0 ;
24032 PyObject * obj1 = 0 ;
24033 PyObject * obj2 = 0 ;
24034 char * kwnames[] = {
24035 (char *) "self",(char *) "month",(char *) "year", NULL
24036 };
24037
24038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24040 if (!SWIG_IsOK(res1)) {
24041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24042 }
24043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24044 if (obj1) {
24045 ecode2 = SWIG_AsVal_int(obj1, &val2);
24046 if (!SWIG_IsOK(ecode2)) {
24047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24048 }
24049 arg2 = static_cast< wxDateTime::Month >(val2);
24050 }
24051 if (obj2) {
24052 ecode3 = SWIG_AsVal_int(obj2, &val3);
24053 if (!SWIG_IsOK(ecode3)) {
24054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24055 }
24056 arg3 = static_cast< int >(val3);
24057 }
24058 {
24059 PyThreadState* __tstate = wxPyBeginAllowThreads();
24060 {
24061 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24062 result = (wxDateTime *) &_result_ref;
24063 }
24064 wxPyEndAllowThreads(__tstate);
24065 if (PyErr_Occurred()) SWIG_fail;
24066 }
24067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24075 PyObject *resultobj = 0;
24076 wxDateTime *arg1 = (wxDateTime *) 0 ;
24077 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24078 int arg3 = (int) wxDateTime::Inv_Year ;
24079 wxDateTime result;
24080 void *argp1 = 0 ;
24081 int res1 = 0 ;
24082 int val2 ;
24083 int ecode2 = 0 ;
24084 int val3 ;
24085 int ecode3 = 0 ;
24086 PyObject * obj0 = 0 ;
24087 PyObject * obj1 = 0 ;
24088 PyObject * obj2 = 0 ;
24089 char * kwnames[] = {
24090 (char *) "self",(char *) "month",(char *) "year", NULL
24091 };
24092
24093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24097 }
24098 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24099 if (obj1) {
24100 ecode2 = SWIG_AsVal_int(obj1, &val2);
24101 if (!SWIG_IsOK(ecode2)) {
24102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24103 }
24104 arg2 = static_cast< wxDateTime::Month >(val2);
24105 }
24106 if (obj2) {
24107 ecode3 = SWIG_AsVal_int(obj2, &val3);
24108 if (!SWIG_IsOK(ecode3)) {
24109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24110 }
24111 arg3 = static_cast< int >(val3);
24112 }
24113 {
24114 PyThreadState* __tstate = wxPyBeginAllowThreads();
24115 result = (arg1)->GetLastMonthDay(arg2,arg3);
24116 wxPyEndAllowThreads(__tstate);
24117 if (PyErr_Occurred()) SWIG_fail;
24118 }
24119 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24120 return resultobj;
24121 fail:
24122 return NULL;
24123 }
24124
24125
24126 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24127 PyObject *resultobj = 0;
24128 wxDateTime *arg1 = (wxDateTime *) 0 ;
24129 int arg2 ;
24130 wxDateTime *result = 0 ;
24131 void *argp1 = 0 ;
24132 int res1 = 0 ;
24133 int val2 ;
24134 int ecode2 = 0 ;
24135 PyObject * obj0 = 0 ;
24136 PyObject * obj1 = 0 ;
24137 char * kwnames[] = {
24138 (char *) "self",(char *) "yday", NULL
24139 };
24140
24141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24143 if (!SWIG_IsOK(res1)) {
24144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24145 }
24146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24147 ecode2 = SWIG_AsVal_int(obj1, &val2);
24148 if (!SWIG_IsOK(ecode2)) {
24149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24150 }
24151 arg2 = static_cast< int >(val2);
24152 {
24153 PyThreadState* __tstate = wxPyBeginAllowThreads();
24154 {
24155 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24156 result = (wxDateTime *) &_result_ref;
24157 }
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24162 return resultobj;
24163 fail:
24164 return NULL;
24165 }
24166
24167
24168 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24169 PyObject *resultobj = 0;
24170 wxDateTime *arg1 = (wxDateTime *) 0 ;
24171 int arg2 ;
24172 wxDateTime result;
24173 void *argp1 = 0 ;
24174 int res1 = 0 ;
24175 int val2 ;
24176 int ecode2 = 0 ;
24177 PyObject * obj0 = 0 ;
24178 PyObject * obj1 = 0 ;
24179 char * kwnames[] = {
24180 (char *) "self",(char *) "yday", NULL
24181 };
24182
24183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24185 if (!SWIG_IsOK(res1)) {
24186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24187 }
24188 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24189 ecode2 = SWIG_AsVal_int(obj1, &val2);
24190 if (!SWIG_IsOK(ecode2)) {
24191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24192 }
24193 arg2 = static_cast< int >(val2);
24194 {
24195 PyThreadState* __tstate = wxPyBeginAllowThreads();
24196 result = (arg1)->GetYearDay(arg2);
24197 wxPyEndAllowThreads(__tstate);
24198 if (PyErr_Occurred()) SWIG_fail;
24199 }
24200 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24201 return resultobj;
24202 fail:
24203 return NULL;
24204 }
24205
24206
24207 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24208 PyObject *resultobj = 0;
24209 wxDateTime *arg1 = (wxDateTime *) 0 ;
24210 double result;
24211 void *argp1 = 0 ;
24212 int res1 = 0 ;
24213 PyObject *swig_obj[1] ;
24214
24215 if (!args) SWIG_fail;
24216 swig_obj[0] = args;
24217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24218 if (!SWIG_IsOK(res1)) {
24219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24220 }
24221 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24222 {
24223 PyThreadState* __tstate = wxPyBeginAllowThreads();
24224 result = (double)(arg1)->GetJulianDayNumber();
24225 wxPyEndAllowThreads(__tstate);
24226 if (PyErr_Occurred()) SWIG_fail;
24227 }
24228 resultobj = SWIG_From_double(static_cast< double >(result));
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24236 PyObject *resultobj = 0;
24237 wxDateTime *arg1 = (wxDateTime *) 0 ;
24238 double result;
24239 void *argp1 = 0 ;
24240 int res1 = 0 ;
24241 PyObject *swig_obj[1] ;
24242
24243 if (!args) SWIG_fail;
24244 swig_obj[0] = args;
24245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24246 if (!SWIG_IsOK(res1)) {
24247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24248 }
24249 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24250 {
24251 PyThreadState* __tstate = wxPyBeginAllowThreads();
24252 result = (double)(arg1)->GetJDN();
24253 wxPyEndAllowThreads(__tstate);
24254 if (PyErr_Occurred()) SWIG_fail;
24255 }
24256 resultobj = SWIG_From_double(static_cast< double >(result));
24257 return resultobj;
24258 fail:
24259 return NULL;
24260 }
24261
24262
24263 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24264 PyObject *resultobj = 0;
24265 wxDateTime *arg1 = (wxDateTime *) 0 ;
24266 double result;
24267 void *argp1 = 0 ;
24268 int res1 = 0 ;
24269 PyObject *swig_obj[1] ;
24270
24271 if (!args) SWIG_fail;
24272 swig_obj[0] = args;
24273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24274 if (!SWIG_IsOK(res1)) {
24275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24276 }
24277 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24278 {
24279 PyThreadState* __tstate = wxPyBeginAllowThreads();
24280 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24281 wxPyEndAllowThreads(__tstate);
24282 if (PyErr_Occurred()) SWIG_fail;
24283 }
24284 resultobj = SWIG_From_double(static_cast< double >(result));
24285 return resultobj;
24286 fail:
24287 return NULL;
24288 }
24289
24290
24291 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24292 PyObject *resultobj = 0;
24293 wxDateTime *arg1 = (wxDateTime *) 0 ;
24294 double result;
24295 void *argp1 = 0 ;
24296 int res1 = 0 ;
24297 PyObject *swig_obj[1] ;
24298
24299 if (!args) SWIG_fail;
24300 swig_obj[0] = args;
24301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24302 if (!SWIG_IsOK(res1)) {
24303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24304 }
24305 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24306 {
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 result = (double)(arg1)->GetMJD();
24309 wxPyEndAllowThreads(__tstate);
24310 if (PyErr_Occurred()) SWIG_fail;
24311 }
24312 resultobj = SWIG_From_double(static_cast< double >(result));
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24320 PyObject *resultobj = 0;
24321 wxDateTime *arg1 = (wxDateTime *) 0 ;
24322 double result;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 PyObject *swig_obj[1] ;
24326
24327 if (!args) SWIG_fail;
24328 swig_obj[0] = args;
24329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24330 if (!SWIG_IsOK(res1)) {
24331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24332 }
24333 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24334 {
24335 PyThreadState* __tstate = wxPyBeginAllowThreads();
24336 result = (double)(arg1)->GetRataDie();
24337 wxPyEndAllowThreads(__tstate);
24338 if (PyErr_Occurred()) SWIG_fail;
24339 }
24340 resultobj = SWIG_From_double(static_cast< double >(result));
24341 return resultobj;
24342 fail:
24343 return NULL;
24344 }
24345
24346
24347 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24348 PyObject *resultobj = 0;
24349 wxDateTime *arg1 = (wxDateTime *) 0 ;
24350 wxDateTime::TimeZone *arg2 = 0 ;
24351 bool arg3 = (bool) false ;
24352 wxDateTime result;
24353 void *argp1 = 0 ;
24354 int res1 = 0 ;
24355 bool temp2 = false ;
24356 bool val3 ;
24357 int ecode3 = 0 ;
24358 PyObject * obj0 = 0 ;
24359 PyObject * obj1 = 0 ;
24360 PyObject * obj2 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24367 if (!SWIG_IsOK(res1)) {
24368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24369 }
24370 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24371 {
24372 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24373 temp2 = true;
24374 }
24375 if (obj2) {
24376 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24377 if (!SWIG_IsOK(ecode3)) {
24378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24379 }
24380 arg3 = static_cast< bool >(val3);
24381 }
24382 {
24383 PyThreadState* __tstate = wxPyBeginAllowThreads();
24384 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24385 wxPyEndAllowThreads(__tstate);
24386 if (PyErr_Occurred()) SWIG_fail;
24387 }
24388 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24389 {
24390 if (temp2) delete arg2;
24391 }
24392 return resultobj;
24393 fail:
24394 {
24395 if (temp2) delete arg2;
24396 }
24397 return NULL;
24398 }
24399
24400
24401 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24402 PyObject *resultobj = 0;
24403 wxDateTime *arg1 = (wxDateTime *) 0 ;
24404 wxDateTime::TimeZone *arg2 = 0 ;
24405 bool arg3 = (bool) false ;
24406 wxDateTime *result = 0 ;
24407 void *argp1 = 0 ;
24408 int res1 = 0 ;
24409 bool temp2 = false ;
24410 bool val3 ;
24411 int ecode3 = 0 ;
24412 PyObject * obj0 = 0 ;
24413 PyObject * obj1 = 0 ;
24414 PyObject * obj2 = 0 ;
24415 char * kwnames[] = {
24416 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24417 };
24418
24419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24421 if (!SWIG_IsOK(res1)) {
24422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24423 }
24424 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24425 {
24426 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24427 temp2 = true;
24428 }
24429 if (obj2) {
24430 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24431 if (!SWIG_IsOK(ecode3)) {
24432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24433 }
24434 arg3 = static_cast< bool >(val3);
24435 }
24436 {
24437 PyThreadState* __tstate = wxPyBeginAllowThreads();
24438 {
24439 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24440 result = (wxDateTime *) &_result_ref;
24441 }
24442 wxPyEndAllowThreads(__tstate);
24443 if (PyErr_Occurred()) SWIG_fail;
24444 }
24445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24446 {
24447 if (temp2) delete arg2;
24448 }
24449 return resultobj;
24450 fail:
24451 {
24452 if (temp2) delete arg2;
24453 }
24454 return NULL;
24455 }
24456
24457
24458 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24459 PyObject *resultobj = 0;
24460 wxDateTime *arg1 = (wxDateTime *) 0 ;
24461 wxDateTime::TimeZone *arg2 = 0 ;
24462 bool arg3 = (bool) false ;
24463 wxDateTime result;
24464 void *argp1 = 0 ;
24465 int res1 = 0 ;
24466 bool temp2 = false ;
24467 bool val3 ;
24468 int ecode3 = 0 ;
24469 PyObject * obj0 = 0 ;
24470 PyObject * obj1 = 0 ;
24471 PyObject * obj2 = 0 ;
24472 char * kwnames[] = {
24473 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24474 };
24475
24476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24478 if (!SWIG_IsOK(res1)) {
24479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24480 }
24481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24482 {
24483 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24484 temp2 = true;
24485 }
24486 if (obj2) {
24487 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24488 if (!SWIG_IsOK(ecode3)) {
24489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24490 }
24491 arg3 = static_cast< bool >(val3);
24492 }
24493 {
24494 PyThreadState* __tstate = wxPyBeginAllowThreads();
24495 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24496 wxPyEndAllowThreads(__tstate);
24497 if (PyErr_Occurred()) SWIG_fail;
24498 }
24499 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24500 {
24501 if (temp2) delete arg2;
24502 }
24503 return resultobj;
24504 fail:
24505 {
24506 if (temp2) delete arg2;
24507 }
24508 return NULL;
24509 }
24510
24511
24512 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24513 PyObject *resultobj = 0;
24514 wxDateTime *arg1 = (wxDateTime *) 0 ;
24515 wxDateTime::TimeZone *arg2 = 0 ;
24516 bool arg3 = (bool) false ;
24517 wxDateTime *result = 0 ;
24518 void *argp1 = 0 ;
24519 int res1 = 0 ;
24520 bool temp2 = false ;
24521 bool val3 ;
24522 int ecode3 = 0 ;
24523 PyObject * obj0 = 0 ;
24524 PyObject * obj1 = 0 ;
24525 PyObject * obj2 = 0 ;
24526 char * kwnames[] = {
24527 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24528 };
24529
24530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24532 if (!SWIG_IsOK(res1)) {
24533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24534 }
24535 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24536 {
24537 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24538 temp2 = true;
24539 }
24540 if (obj2) {
24541 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24542 if (!SWIG_IsOK(ecode3)) {
24543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24544 }
24545 arg3 = static_cast< bool >(val3);
24546 }
24547 {
24548 PyThreadState* __tstate = wxPyBeginAllowThreads();
24549 {
24550 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24551 result = (wxDateTime *) &_result_ref;
24552 }
24553 wxPyEndAllowThreads(__tstate);
24554 if (PyErr_Occurred()) SWIG_fail;
24555 }
24556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24557 {
24558 if (temp2) delete arg2;
24559 }
24560 return resultobj;
24561 fail:
24562 {
24563 if (temp2) delete arg2;
24564 }
24565 return NULL;
24566 }
24567
24568
24569 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24570 PyObject *resultobj = 0;
24571 wxDateTime *arg1 = (wxDateTime *) 0 ;
24572 bool arg2 = (bool) false ;
24573 wxDateTime result;
24574 void *argp1 = 0 ;
24575 int res1 = 0 ;
24576 bool val2 ;
24577 int ecode2 = 0 ;
24578 PyObject * obj0 = 0 ;
24579 PyObject * obj1 = 0 ;
24580 char * kwnames[] = {
24581 (char *) "self",(char *) "noDST", NULL
24582 };
24583
24584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24586 if (!SWIG_IsOK(res1)) {
24587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24588 }
24589 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24590 if (obj1) {
24591 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24592 if (!SWIG_IsOK(ecode2)) {
24593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24594 }
24595 arg2 = static_cast< bool >(val2);
24596 }
24597 {
24598 PyThreadState* __tstate = wxPyBeginAllowThreads();
24599 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24600 wxPyEndAllowThreads(__tstate);
24601 if (PyErr_Occurred()) SWIG_fail;
24602 }
24603 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24604 return resultobj;
24605 fail:
24606 return NULL;
24607 }
24608
24609
24610 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24611 PyObject *resultobj = 0;
24612 wxDateTime *arg1 = (wxDateTime *) 0 ;
24613 bool arg2 = (bool) false ;
24614 wxDateTime *result = 0 ;
24615 void *argp1 = 0 ;
24616 int res1 = 0 ;
24617 bool val2 ;
24618 int ecode2 = 0 ;
24619 PyObject * obj0 = 0 ;
24620 PyObject * obj1 = 0 ;
24621 char * kwnames[] = {
24622 (char *) "self",(char *) "noDST", NULL
24623 };
24624
24625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24627 if (!SWIG_IsOK(res1)) {
24628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24629 }
24630 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24631 if (obj1) {
24632 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24633 if (!SWIG_IsOK(ecode2)) {
24634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24635 }
24636 arg2 = static_cast< bool >(val2);
24637 }
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 {
24641 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24642 result = (wxDateTime *) &_result_ref;
24643 }
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24648 return resultobj;
24649 fail:
24650 return NULL;
24651 }
24652
24653
24654 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24655 PyObject *resultobj = 0;
24656 wxDateTime *arg1 = (wxDateTime *) 0 ;
24657 bool arg2 = (bool) false ;
24658 wxDateTime result;
24659 void *argp1 = 0 ;
24660 int res1 = 0 ;
24661 bool val2 ;
24662 int ecode2 = 0 ;
24663 PyObject * obj0 = 0 ;
24664 PyObject * obj1 = 0 ;
24665 char * kwnames[] = {
24666 (char *) "self",(char *) "noDST", NULL
24667 };
24668
24669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24671 if (!SWIG_IsOK(res1)) {
24672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24673 }
24674 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24675 if (obj1) {
24676 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24677 if (!SWIG_IsOK(ecode2)) {
24678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24679 }
24680 arg2 = static_cast< bool >(val2);
24681 }
24682 {
24683 PyThreadState* __tstate = wxPyBeginAllowThreads();
24684 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24685 wxPyEndAllowThreads(__tstate);
24686 if (PyErr_Occurred()) SWIG_fail;
24687 }
24688 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24689 return resultobj;
24690 fail:
24691 return NULL;
24692 }
24693
24694
24695 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24696 PyObject *resultobj = 0;
24697 wxDateTime *arg1 = (wxDateTime *) 0 ;
24698 bool arg2 = (bool) false ;
24699 wxDateTime *result = 0 ;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 bool val2 ;
24703 int ecode2 = 0 ;
24704 PyObject * obj0 = 0 ;
24705 PyObject * obj1 = 0 ;
24706 char * kwnames[] = {
24707 (char *) "self",(char *) "noDST", NULL
24708 };
24709
24710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24712 if (!SWIG_IsOK(res1)) {
24713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24714 }
24715 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24716 if (obj1) {
24717 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24718 if (!SWIG_IsOK(ecode2)) {
24719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24720 }
24721 arg2 = static_cast< bool >(val2);
24722 }
24723 {
24724 PyThreadState* __tstate = wxPyBeginAllowThreads();
24725 {
24726 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24727 result = (wxDateTime *) &_result_ref;
24728 }
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24740 PyObject *resultobj = 0;
24741 wxDateTime *arg1 = (wxDateTime *) 0 ;
24742 bool arg2 = (bool) false ;
24743 wxDateTime result;
24744 void *argp1 = 0 ;
24745 int res1 = 0 ;
24746 bool val2 ;
24747 int ecode2 = 0 ;
24748 PyObject * obj0 = 0 ;
24749 PyObject * obj1 = 0 ;
24750 char * kwnames[] = {
24751 (char *) "self",(char *) "noDST", NULL
24752 };
24753
24754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24756 if (!SWIG_IsOK(res1)) {
24757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24758 }
24759 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24760 if (obj1) {
24761 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24762 if (!SWIG_IsOK(ecode2)) {
24763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24764 }
24765 arg2 = static_cast< bool >(val2);
24766 }
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24781 PyObject *resultobj = 0;
24782 wxDateTime *arg1 = (wxDateTime *) 0 ;
24783 bool arg2 = (bool) false ;
24784 wxDateTime *result = 0 ;
24785 void *argp1 = 0 ;
24786 int res1 = 0 ;
24787 bool val2 ;
24788 int ecode2 = 0 ;
24789 PyObject * obj0 = 0 ;
24790 PyObject * obj1 = 0 ;
24791 char * kwnames[] = {
24792 (char *) "self",(char *) "noDST", NULL
24793 };
24794
24795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24799 }
24800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24801 if (obj1) {
24802 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24803 if (!SWIG_IsOK(ecode2)) {
24804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24805 }
24806 arg2 = static_cast< bool >(val2);
24807 }
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 {
24811 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24812 result = (wxDateTime *) &_result_ref;
24813 }
24814 wxPyEndAllowThreads(__tstate);
24815 if (PyErr_Occurred()) SWIG_fail;
24816 }
24817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24818 return resultobj;
24819 fail:
24820 return NULL;
24821 }
24822
24823
24824 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24825 PyObject *resultobj = 0;
24826 wxDateTime *arg1 = (wxDateTime *) 0 ;
24827 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24828 int result;
24829 void *argp1 = 0 ;
24830 int res1 = 0 ;
24831 int val2 ;
24832 int ecode2 = 0 ;
24833 PyObject * obj0 = 0 ;
24834 PyObject * obj1 = 0 ;
24835 char * kwnames[] = {
24836 (char *) "self",(char *) "country", NULL
24837 };
24838
24839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24841 if (!SWIG_IsOK(res1)) {
24842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24843 }
24844 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24845 if (obj1) {
24846 ecode2 = SWIG_AsVal_int(obj1, &val2);
24847 if (!SWIG_IsOK(ecode2)) {
24848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24849 }
24850 arg2 = static_cast< wxDateTime::Country >(val2);
24851 }
24852 {
24853 PyThreadState* __tstate = wxPyBeginAllowThreads();
24854 result = (int)(arg1)->IsDST(arg2);
24855 wxPyEndAllowThreads(__tstate);
24856 if (PyErr_Occurred()) SWIG_fail;
24857 }
24858 resultobj = SWIG_From_int(static_cast< int >(result));
24859 return resultobj;
24860 fail:
24861 return NULL;
24862 }
24863
24864
24865 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24866 PyObject *resultobj = 0;
24867 wxDateTime *arg1 = (wxDateTime *) 0 ;
24868 bool result;
24869 void *argp1 = 0 ;
24870 int res1 = 0 ;
24871 PyObject *swig_obj[1] ;
24872
24873 if (!args) SWIG_fail;
24874 swig_obj[0] = args;
24875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24876 if (!SWIG_IsOK(res1)) {
24877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24878 }
24879 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24880 {
24881 PyThreadState* __tstate = wxPyBeginAllowThreads();
24882 result = (bool)((wxDateTime const *)arg1)->IsValid();
24883 wxPyEndAllowThreads(__tstate);
24884 if (PyErr_Occurred()) SWIG_fail;
24885 }
24886 {
24887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24888 }
24889 return resultobj;
24890 fail:
24891 return NULL;
24892 }
24893
24894
24895 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24896 PyObject *resultobj = 0;
24897 wxDateTime *arg1 = (wxDateTime *) 0 ;
24898 time_t result;
24899 void *argp1 = 0 ;
24900 int res1 = 0 ;
24901 PyObject *swig_obj[1] ;
24902
24903 if (!args) SWIG_fail;
24904 swig_obj[0] = args;
24905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24906 if (!SWIG_IsOK(res1)) {
24907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24908 }
24909 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24910 {
24911 PyThreadState* __tstate = wxPyBeginAllowThreads();
24912 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24913 wxPyEndAllowThreads(__tstate);
24914 if (PyErr_Occurred()) SWIG_fail;
24915 }
24916 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24917 return resultobj;
24918 fail:
24919 return NULL;
24920 }
24921
24922
24923 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24924 PyObject *resultobj = 0;
24925 wxDateTime *arg1 = (wxDateTime *) 0 ;
24926 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24927 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24928 int result;
24929 void *argp1 = 0 ;
24930 int res1 = 0 ;
24931 bool temp2 = false ;
24932 PyObject * obj0 = 0 ;
24933 PyObject * obj1 = 0 ;
24934 char * kwnames[] = {
24935 (char *) "self",(char *) "tz", NULL
24936 };
24937
24938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24940 if (!SWIG_IsOK(res1)) {
24941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24942 }
24943 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24944 if (obj1) {
24945 {
24946 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24947 temp2 = true;
24948 }
24949 }
24950 {
24951 PyThreadState* __tstate = wxPyBeginAllowThreads();
24952 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24953 wxPyEndAllowThreads(__tstate);
24954 if (PyErr_Occurred()) SWIG_fail;
24955 }
24956 resultobj = SWIG_From_int(static_cast< int >(result));
24957 {
24958 if (temp2) delete arg2;
24959 }
24960 return resultobj;
24961 fail:
24962 {
24963 if (temp2) delete arg2;
24964 }
24965 return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj = 0;
24971 wxDateTime *arg1 = (wxDateTime *) 0 ;
24972 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24973 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24974 wxDateTime::Month result;
24975 void *argp1 = 0 ;
24976 int res1 = 0 ;
24977 bool temp2 = false ;
24978 PyObject * obj0 = 0 ;
24979 PyObject * obj1 = 0 ;
24980 char * kwnames[] = {
24981 (char *) "self",(char *) "tz", NULL
24982 };
24983
24984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24986 if (!SWIG_IsOK(res1)) {
24987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24988 }
24989 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24990 if (obj1) {
24991 {
24992 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24993 temp2 = true;
24994 }
24995 }
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 resultobj = SWIG_From_int(static_cast< int >(result));
25003 {
25004 if (temp2) delete arg2;
25005 }
25006 return resultobj;
25007 fail:
25008 {
25009 if (temp2) delete arg2;
25010 }
25011 return NULL;
25012 }
25013
25014
25015 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25016 PyObject *resultobj = 0;
25017 wxDateTime *arg1 = (wxDateTime *) 0 ;
25018 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25019 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25020 int result;
25021 void *argp1 = 0 ;
25022 int res1 = 0 ;
25023 bool temp2 = false ;
25024 PyObject * obj0 = 0 ;
25025 PyObject * obj1 = 0 ;
25026 char * kwnames[] = {
25027 (char *) "self",(char *) "tz", NULL
25028 };
25029
25030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25032 if (!SWIG_IsOK(res1)) {
25033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25034 }
25035 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25036 if (obj1) {
25037 {
25038 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25039 temp2 = true;
25040 }
25041 }
25042 {
25043 PyThreadState* __tstate = wxPyBeginAllowThreads();
25044 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 resultobj = SWIG_From_int(static_cast< int >(result));
25049 {
25050 if (temp2) delete arg2;
25051 }
25052 return resultobj;
25053 fail:
25054 {
25055 if (temp2) delete arg2;
25056 }
25057 return NULL;
25058 }
25059
25060
25061 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25062 PyObject *resultobj = 0;
25063 wxDateTime *arg1 = (wxDateTime *) 0 ;
25064 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25065 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25066 wxDateTime::WeekDay result;
25067 void *argp1 = 0 ;
25068 int res1 = 0 ;
25069 bool temp2 = false ;
25070 PyObject * obj0 = 0 ;
25071 PyObject * obj1 = 0 ;
25072 char * kwnames[] = {
25073 (char *) "self",(char *) "tz", NULL
25074 };
25075
25076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25078 if (!SWIG_IsOK(res1)) {
25079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25080 }
25081 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25082 if (obj1) {
25083 {
25084 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25085 temp2 = true;
25086 }
25087 }
25088 {
25089 PyThreadState* __tstate = wxPyBeginAllowThreads();
25090 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 resultobj = SWIG_From_int(static_cast< int >(result));
25095 {
25096 if (temp2) delete arg2;
25097 }
25098 return resultobj;
25099 fail:
25100 {
25101 if (temp2) delete arg2;
25102 }
25103 return NULL;
25104 }
25105
25106
25107 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25108 PyObject *resultobj = 0;
25109 wxDateTime *arg1 = (wxDateTime *) 0 ;
25110 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25111 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25112 int result;
25113 void *argp1 = 0 ;
25114 int res1 = 0 ;
25115 bool temp2 = false ;
25116 PyObject * obj0 = 0 ;
25117 PyObject * obj1 = 0 ;
25118 char * kwnames[] = {
25119 (char *) "self",(char *) "tz", NULL
25120 };
25121
25122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25124 if (!SWIG_IsOK(res1)) {
25125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25126 }
25127 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25128 if (obj1) {
25129 {
25130 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25131 temp2 = true;
25132 }
25133 }
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25137 wxPyEndAllowThreads(__tstate);
25138 if (PyErr_Occurred()) SWIG_fail;
25139 }
25140 resultobj = SWIG_From_int(static_cast< int >(result));
25141 {
25142 if (temp2) delete arg2;
25143 }
25144 return resultobj;
25145 fail:
25146 {
25147 if (temp2) delete arg2;
25148 }
25149 return NULL;
25150 }
25151
25152
25153 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25154 PyObject *resultobj = 0;
25155 wxDateTime *arg1 = (wxDateTime *) 0 ;
25156 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25157 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25158 int result;
25159 void *argp1 = 0 ;
25160 int res1 = 0 ;
25161 bool temp2 = false ;
25162 PyObject * obj0 = 0 ;
25163 PyObject * obj1 = 0 ;
25164 char * kwnames[] = {
25165 (char *) "self",(char *) "tz", NULL
25166 };
25167
25168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25170 if (!SWIG_IsOK(res1)) {
25171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25172 }
25173 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25174 if (obj1) {
25175 {
25176 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25177 temp2 = true;
25178 }
25179 }
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_From_int(static_cast< int >(result));
25187 {
25188 if (temp2) delete arg2;
25189 }
25190 return resultobj;
25191 fail:
25192 {
25193 if (temp2) delete arg2;
25194 }
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25200 PyObject *resultobj = 0;
25201 wxDateTime *arg1 = (wxDateTime *) 0 ;
25202 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25203 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25204 int result;
25205 void *argp1 = 0 ;
25206 int res1 = 0 ;
25207 bool temp2 = false ;
25208 PyObject * obj0 = 0 ;
25209 PyObject * obj1 = 0 ;
25210 char * kwnames[] = {
25211 (char *) "self",(char *) "tz", NULL
25212 };
25213
25214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25216 if (!SWIG_IsOK(res1)) {
25217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25218 }
25219 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25220 if (obj1) {
25221 {
25222 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25223 temp2 = true;
25224 }
25225 }
25226 {
25227 PyThreadState* __tstate = wxPyBeginAllowThreads();
25228 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25229 wxPyEndAllowThreads(__tstate);
25230 if (PyErr_Occurred()) SWIG_fail;
25231 }
25232 resultobj = SWIG_From_int(static_cast< int >(result));
25233 {
25234 if (temp2) delete arg2;
25235 }
25236 return resultobj;
25237 fail:
25238 {
25239 if (temp2) delete arg2;
25240 }
25241 return NULL;
25242 }
25243
25244
25245 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25246 PyObject *resultobj = 0;
25247 wxDateTime *arg1 = (wxDateTime *) 0 ;
25248 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25249 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25250 int result;
25251 void *argp1 = 0 ;
25252 int res1 = 0 ;
25253 bool temp2 = false ;
25254 PyObject * obj0 = 0 ;
25255 PyObject * obj1 = 0 ;
25256 char * kwnames[] = {
25257 (char *) "self",(char *) "tz", NULL
25258 };
25259
25260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25262 if (!SWIG_IsOK(res1)) {
25263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25264 }
25265 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25266 if (obj1) {
25267 {
25268 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25269 temp2 = true;
25270 }
25271 }
25272 {
25273 PyThreadState* __tstate = wxPyBeginAllowThreads();
25274 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 resultobj = SWIG_From_int(static_cast< int >(result));
25279 {
25280 if (temp2) delete arg2;
25281 }
25282 return resultobj;
25283 fail:
25284 {
25285 if (temp2) delete arg2;
25286 }
25287 return NULL;
25288 }
25289
25290
25291 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25292 PyObject *resultobj = 0;
25293 wxDateTime *arg1 = (wxDateTime *) 0 ;
25294 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25295 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25296 int result;
25297 void *argp1 = 0 ;
25298 int res1 = 0 ;
25299 bool temp2 = false ;
25300 PyObject * obj0 = 0 ;
25301 PyObject * obj1 = 0 ;
25302 char * kwnames[] = {
25303 (char *) "self",(char *) "tz", NULL
25304 };
25305
25306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25308 if (!SWIG_IsOK(res1)) {
25309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25310 }
25311 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25312 if (obj1) {
25313 {
25314 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25315 temp2 = true;
25316 }
25317 }
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25321 wxPyEndAllowThreads(__tstate);
25322 if (PyErr_Occurred()) SWIG_fail;
25323 }
25324 resultobj = SWIG_From_int(static_cast< int >(result));
25325 {
25326 if (temp2) delete arg2;
25327 }
25328 return resultobj;
25329 fail:
25330 {
25331 if (temp2) delete arg2;
25332 }
25333 return NULL;
25334 }
25335
25336
25337 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25338 PyObject *resultobj = 0;
25339 wxDateTime *arg1 = (wxDateTime *) 0 ;
25340 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25341 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25342 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25343 int result;
25344 void *argp1 = 0 ;
25345 int res1 = 0 ;
25346 int val2 ;
25347 int ecode2 = 0 ;
25348 bool temp3 = false ;
25349 PyObject * obj0 = 0 ;
25350 PyObject * obj1 = 0 ;
25351 PyObject * obj2 = 0 ;
25352 char * kwnames[] = {
25353 (char *) "self",(char *) "flags",(char *) "tz", NULL
25354 };
25355
25356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25358 if (!SWIG_IsOK(res1)) {
25359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25360 }
25361 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25362 if (obj1) {
25363 ecode2 = SWIG_AsVal_int(obj1, &val2);
25364 if (!SWIG_IsOK(ecode2)) {
25365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25366 }
25367 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25368 }
25369 if (obj2) {
25370 {
25371 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25372 temp3 = true;
25373 }
25374 }
25375 {
25376 PyThreadState* __tstate = wxPyBeginAllowThreads();
25377 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25378 wxPyEndAllowThreads(__tstate);
25379 if (PyErr_Occurred()) SWIG_fail;
25380 }
25381 resultobj = SWIG_From_int(static_cast< int >(result));
25382 {
25383 if (temp3) delete arg3;
25384 }
25385 return resultobj;
25386 fail:
25387 {
25388 if (temp3) delete arg3;
25389 }
25390 return NULL;
25391 }
25392
25393
25394 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25395 PyObject *resultobj = 0;
25396 wxDateTime *arg1 = (wxDateTime *) 0 ;
25397 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25398 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25399 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25400 int result;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 int val2 ;
25404 int ecode2 = 0 ;
25405 bool temp3 = false ;
25406 PyObject * obj0 = 0 ;
25407 PyObject * obj1 = 0 ;
25408 PyObject * obj2 = 0 ;
25409 char * kwnames[] = {
25410 (char *) "self",(char *) "flags",(char *) "tz", NULL
25411 };
25412
25413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25415 if (!SWIG_IsOK(res1)) {
25416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25417 }
25418 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25419 if (obj1) {
25420 ecode2 = SWIG_AsVal_int(obj1, &val2);
25421 if (!SWIG_IsOK(ecode2)) {
25422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25423 }
25424 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25425 }
25426 if (obj2) {
25427 {
25428 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25429 temp3 = true;
25430 }
25431 }
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 resultobj = SWIG_From_int(static_cast< int >(result));
25439 {
25440 if (temp3) delete arg3;
25441 }
25442 return resultobj;
25443 fail:
25444 {
25445 if (temp3) delete arg3;
25446 }
25447 return NULL;
25448 }
25449
25450
25451 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25452 PyObject *resultobj = 0;
25453 wxDateTime *arg1 = (wxDateTime *) 0 ;
25454 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25455 bool result;
25456 void *argp1 = 0 ;
25457 int res1 = 0 ;
25458 int val2 ;
25459 int ecode2 = 0 ;
25460 PyObject * obj0 = 0 ;
25461 PyObject * obj1 = 0 ;
25462 char * kwnames[] = {
25463 (char *) "self",(char *) "country", NULL
25464 };
25465
25466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25468 if (!SWIG_IsOK(res1)) {
25469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25470 }
25471 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25472 if (obj1) {
25473 ecode2 = SWIG_AsVal_int(obj1, &val2);
25474 if (!SWIG_IsOK(ecode2)) {
25475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25476 }
25477 arg2 = static_cast< wxDateTime::Country >(val2);
25478 }
25479 {
25480 PyThreadState* __tstate = wxPyBeginAllowThreads();
25481 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 {
25486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25487 }
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25495 PyObject *resultobj = 0;
25496 wxDateTime *arg1 = (wxDateTime *) 0 ;
25497 wxDateTime *arg2 = 0 ;
25498 bool result;
25499 void *argp1 = 0 ;
25500 int res1 = 0 ;
25501 void *argp2 = 0 ;
25502 int res2 = 0 ;
25503 PyObject * obj0 = 0 ;
25504 PyObject * obj1 = 0 ;
25505 char * kwnames[] = {
25506 (char *) "self",(char *) "datetime", NULL
25507 };
25508
25509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25511 if (!SWIG_IsOK(res1)) {
25512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25513 }
25514 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25515 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25516 if (!SWIG_IsOK(res2)) {
25517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25518 }
25519 if (!argp2) {
25520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25521 }
25522 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25523 {
25524 PyThreadState* __tstate = wxPyBeginAllowThreads();
25525 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25526 wxPyEndAllowThreads(__tstate);
25527 if (PyErr_Occurred()) SWIG_fail;
25528 }
25529 {
25530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25531 }
25532 return resultobj;
25533 fail:
25534 return NULL;
25535 }
25536
25537
25538 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25539 PyObject *resultobj = 0;
25540 wxDateTime *arg1 = (wxDateTime *) 0 ;
25541 wxDateTime *arg2 = 0 ;
25542 bool result;
25543 void *argp1 = 0 ;
25544 int res1 = 0 ;
25545 void *argp2 = 0 ;
25546 int res2 = 0 ;
25547 PyObject * obj0 = 0 ;
25548 PyObject * obj1 = 0 ;
25549 char * kwnames[] = {
25550 (char *) "self",(char *) "datetime", NULL
25551 };
25552
25553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25555 if (!SWIG_IsOK(res1)) {
25556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25557 }
25558 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25559 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25560 if (!SWIG_IsOK(res2)) {
25561 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25562 }
25563 if (!argp2) {
25564 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25565 }
25566 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25567 {
25568 PyThreadState* __tstate = wxPyBeginAllowThreads();
25569 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25570 wxPyEndAllowThreads(__tstate);
25571 if (PyErr_Occurred()) SWIG_fail;
25572 }
25573 {
25574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25575 }
25576 return resultobj;
25577 fail:
25578 return NULL;
25579 }
25580
25581
25582 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25583 PyObject *resultobj = 0;
25584 wxDateTime *arg1 = (wxDateTime *) 0 ;
25585 wxDateTime *arg2 = 0 ;
25586 bool result;
25587 void *argp1 = 0 ;
25588 int res1 = 0 ;
25589 void *argp2 = 0 ;
25590 int res2 = 0 ;
25591 PyObject * obj0 = 0 ;
25592 PyObject * obj1 = 0 ;
25593 char * kwnames[] = {
25594 (char *) "self",(char *) "datetime", NULL
25595 };
25596
25597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25599 if (!SWIG_IsOK(res1)) {
25600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25601 }
25602 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25603 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25604 if (!SWIG_IsOK(res2)) {
25605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25606 }
25607 if (!argp2) {
25608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25609 }
25610 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25611 {
25612 PyThreadState* __tstate = wxPyBeginAllowThreads();
25613 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25614 wxPyEndAllowThreads(__tstate);
25615 if (PyErr_Occurred()) SWIG_fail;
25616 }
25617 {
25618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25619 }
25620 return resultobj;
25621 fail:
25622 return NULL;
25623 }
25624
25625
25626 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25627 PyObject *resultobj = 0;
25628 wxDateTime *arg1 = (wxDateTime *) 0 ;
25629 wxDateTime *arg2 = 0 ;
25630 wxDateTime *arg3 = 0 ;
25631 bool result;
25632 void *argp1 = 0 ;
25633 int res1 = 0 ;
25634 void *argp2 = 0 ;
25635 int res2 = 0 ;
25636 void *argp3 = 0 ;
25637 int res3 = 0 ;
25638 PyObject * obj0 = 0 ;
25639 PyObject * obj1 = 0 ;
25640 PyObject * obj2 = 0 ;
25641 char * kwnames[] = {
25642 (char *) "self",(char *) "t1",(char *) "t2", NULL
25643 };
25644
25645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25647 if (!SWIG_IsOK(res1)) {
25648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25649 }
25650 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25652 if (!SWIG_IsOK(res2)) {
25653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25654 }
25655 if (!argp2) {
25656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25657 }
25658 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25659 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25660 if (!SWIG_IsOK(res3)) {
25661 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25662 }
25663 if (!argp3) {
25664 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25665 }
25666 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25667 {
25668 PyThreadState* __tstate = wxPyBeginAllowThreads();
25669 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25670 wxPyEndAllowThreads(__tstate);
25671 if (PyErr_Occurred()) SWIG_fail;
25672 }
25673 {
25674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25675 }
25676 return resultobj;
25677 fail:
25678 return NULL;
25679 }
25680
25681
25682 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25683 PyObject *resultobj = 0;
25684 wxDateTime *arg1 = (wxDateTime *) 0 ;
25685 wxDateTime *arg2 = 0 ;
25686 wxDateTime *arg3 = 0 ;
25687 bool result;
25688 void *argp1 = 0 ;
25689 int res1 = 0 ;
25690 void *argp2 = 0 ;
25691 int res2 = 0 ;
25692 void *argp3 = 0 ;
25693 int res3 = 0 ;
25694 PyObject * obj0 = 0 ;
25695 PyObject * obj1 = 0 ;
25696 PyObject * obj2 = 0 ;
25697 char * kwnames[] = {
25698 (char *) "self",(char *) "t1",(char *) "t2", NULL
25699 };
25700
25701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25703 if (!SWIG_IsOK(res1)) {
25704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25705 }
25706 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25707 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25708 if (!SWIG_IsOK(res2)) {
25709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25710 }
25711 if (!argp2) {
25712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25713 }
25714 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25715 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25716 if (!SWIG_IsOK(res3)) {
25717 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25718 }
25719 if (!argp3) {
25720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25721 }
25722 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25723 {
25724 PyThreadState* __tstate = wxPyBeginAllowThreads();
25725 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25726 wxPyEndAllowThreads(__tstate);
25727 if (PyErr_Occurred()) SWIG_fail;
25728 }
25729 {
25730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25731 }
25732 return resultobj;
25733 fail:
25734 return NULL;
25735 }
25736
25737
25738 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25739 PyObject *resultobj = 0;
25740 wxDateTime *arg1 = (wxDateTime *) 0 ;
25741 wxDateTime *arg2 = 0 ;
25742 bool result;
25743 void *argp1 = 0 ;
25744 int res1 = 0 ;
25745 void *argp2 = 0 ;
25746 int res2 = 0 ;
25747 PyObject * obj0 = 0 ;
25748 PyObject * obj1 = 0 ;
25749 char * kwnames[] = {
25750 (char *) "self",(char *) "dt", NULL
25751 };
25752
25753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25755 if (!SWIG_IsOK(res1)) {
25756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25757 }
25758 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25760 if (!SWIG_IsOK(res2)) {
25761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25762 }
25763 if (!argp2) {
25764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25765 }
25766 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25767 {
25768 PyThreadState* __tstate = wxPyBeginAllowThreads();
25769 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25770 wxPyEndAllowThreads(__tstate);
25771 if (PyErr_Occurred()) SWIG_fail;
25772 }
25773 {
25774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25775 }
25776 return resultobj;
25777 fail:
25778 return NULL;
25779 }
25780
25781
25782 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25783 PyObject *resultobj = 0;
25784 wxDateTime *arg1 = (wxDateTime *) 0 ;
25785 wxDateTime *arg2 = 0 ;
25786 bool result;
25787 void *argp1 = 0 ;
25788 int res1 = 0 ;
25789 void *argp2 = 0 ;
25790 int res2 = 0 ;
25791 PyObject * obj0 = 0 ;
25792 PyObject * obj1 = 0 ;
25793 char * kwnames[] = {
25794 (char *) "self",(char *) "dt", NULL
25795 };
25796
25797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25799 if (!SWIG_IsOK(res1)) {
25800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25801 }
25802 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25803 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25804 if (!SWIG_IsOK(res2)) {
25805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25806 }
25807 if (!argp2) {
25808 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25809 }
25810 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25814 wxPyEndAllowThreads(__tstate);
25815 if (PyErr_Occurred()) SWIG_fail;
25816 }
25817 {
25818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25819 }
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25827 PyObject *resultobj = 0;
25828 wxDateTime *arg1 = (wxDateTime *) 0 ;
25829 wxDateTime *arg2 = 0 ;
25830 wxTimeSpan *arg3 = 0 ;
25831 bool result;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 void *argp2 = 0 ;
25835 int res2 = 0 ;
25836 void *argp3 = 0 ;
25837 int res3 = 0 ;
25838 PyObject * obj0 = 0 ;
25839 PyObject * obj1 = 0 ;
25840 PyObject * obj2 = 0 ;
25841 char * kwnames[] = {
25842 (char *) "self",(char *) "dt",(char *) "ts", NULL
25843 };
25844
25845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25847 if (!SWIG_IsOK(res1)) {
25848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25849 }
25850 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25851 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25852 if (!SWIG_IsOK(res2)) {
25853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25854 }
25855 if (!argp2) {
25856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25857 }
25858 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25859 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25860 if (!SWIG_IsOK(res3)) {
25861 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25862 }
25863 if (!argp3) {
25864 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25865 }
25866 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25867 {
25868 PyThreadState* __tstate = wxPyBeginAllowThreads();
25869 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25870 wxPyEndAllowThreads(__tstate);
25871 if (PyErr_Occurred()) SWIG_fail;
25872 }
25873 {
25874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25875 }
25876 return resultobj;
25877 fail:
25878 return NULL;
25879 }
25880
25881
25882 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25883 PyObject *resultobj = 0;
25884 wxDateTime *arg1 = (wxDateTime *) 0 ;
25885 wxTimeSpan *arg2 = 0 ;
25886 wxDateTime *result = 0 ;
25887 void *argp1 = 0 ;
25888 int res1 = 0 ;
25889 void *argp2 = 0 ;
25890 int res2 = 0 ;
25891 PyObject * obj0 = 0 ;
25892 PyObject * obj1 = 0 ;
25893 char * kwnames[] = {
25894 (char *) "self",(char *) "diff", NULL
25895 };
25896
25897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25899 if (!SWIG_IsOK(res1)) {
25900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25901 }
25902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25903 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25904 if (!SWIG_IsOK(res2)) {
25905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25906 }
25907 if (!argp2) {
25908 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25909 }
25910 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25911 {
25912 PyThreadState* __tstate = wxPyBeginAllowThreads();
25913 {
25914 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25915 result = (wxDateTime *) &_result_ref;
25916 }
25917 wxPyEndAllowThreads(__tstate);
25918 if (PyErr_Occurred()) SWIG_fail;
25919 }
25920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25921 return resultobj;
25922 fail:
25923 return NULL;
25924 }
25925
25926
25927 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25928 PyObject *resultobj = 0;
25929 wxDateTime *arg1 = (wxDateTime *) 0 ;
25930 wxDateSpan *arg2 = 0 ;
25931 wxDateTime *result = 0 ;
25932 void *argp1 = 0 ;
25933 int res1 = 0 ;
25934 void *argp2 = 0 ;
25935 int res2 = 0 ;
25936 PyObject * obj0 = 0 ;
25937 PyObject * obj1 = 0 ;
25938 char * kwnames[] = {
25939 (char *) "self",(char *) "diff", NULL
25940 };
25941
25942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25944 if (!SWIG_IsOK(res1)) {
25945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25946 }
25947 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25949 if (!SWIG_IsOK(res2)) {
25950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25951 }
25952 if (!argp2) {
25953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25954 }
25955 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25956 {
25957 PyThreadState* __tstate = wxPyBeginAllowThreads();
25958 {
25959 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25960 result = (wxDateTime *) &_result_ref;
25961 }
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25973 PyObject *resultobj = 0;
25974 wxDateTime *arg1 = (wxDateTime *) 0 ;
25975 wxTimeSpan *arg2 = 0 ;
25976 wxDateTime *result = 0 ;
25977 void *argp1 = 0 ;
25978 int res1 = 0 ;
25979 void *argp2 = 0 ;
25980 int res2 = 0 ;
25981 PyObject * obj0 = 0 ;
25982 PyObject * obj1 = 0 ;
25983 char * kwnames[] = {
25984 (char *) "self",(char *) "diff", NULL
25985 };
25986
25987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
25988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25989 if (!SWIG_IsOK(res1)) {
25990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25991 }
25992 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25994 if (!SWIG_IsOK(res2)) {
25995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25996 }
25997 if (!argp2) {
25998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25999 }
26000 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 {
26004 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26005 result = (wxDateTime *) &_result_ref;
26006 }
26007 wxPyEndAllowThreads(__tstate);
26008 if (PyErr_Occurred()) SWIG_fail;
26009 }
26010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26011 return resultobj;
26012 fail:
26013 return NULL;
26014 }
26015
26016
26017 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26018 PyObject *resultobj = 0;
26019 wxDateTime *arg1 = (wxDateTime *) 0 ;
26020 wxDateSpan *arg2 = 0 ;
26021 wxDateTime *result = 0 ;
26022 void *argp1 = 0 ;
26023 int res1 = 0 ;
26024 void *argp2 = 0 ;
26025 int res2 = 0 ;
26026 PyObject * obj0 = 0 ;
26027 PyObject * obj1 = 0 ;
26028 char * kwnames[] = {
26029 (char *) "self",(char *) "diff", NULL
26030 };
26031
26032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26034 if (!SWIG_IsOK(res1)) {
26035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26036 }
26037 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26038 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26039 if (!SWIG_IsOK(res2)) {
26040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26041 }
26042 if (!argp2) {
26043 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26044 }
26045 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 {
26049 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26050 result = (wxDateTime *) &_result_ref;
26051 }
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26063 PyObject *resultobj = 0;
26064 wxDateTime *arg1 = (wxDateTime *) 0 ;
26065 wxDateTime *arg2 = 0 ;
26066 wxTimeSpan result;
26067 void *argp1 = 0 ;
26068 int res1 = 0 ;
26069 void *argp2 = 0 ;
26070 int res2 = 0 ;
26071 PyObject * obj0 = 0 ;
26072 PyObject * obj1 = 0 ;
26073 char * kwnames[] = {
26074 (char *) "self",(char *) "dt", NULL
26075 };
26076
26077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26079 if (!SWIG_IsOK(res1)) {
26080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26081 }
26082 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26083 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26084 if (!SWIG_IsOK(res2)) {
26085 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26086 }
26087 if (!argp2) {
26088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26089 }
26090 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26091 {
26092 PyThreadState* __tstate = wxPyBeginAllowThreads();
26093 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26094 wxPyEndAllowThreads(__tstate);
26095 if (PyErr_Occurred()) SWIG_fail;
26096 }
26097 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26105 PyObject *resultobj = 0;
26106 wxDateTime *arg1 = (wxDateTime *) 0 ;
26107 wxTimeSpan *arg2 = 0 ;
26108 wxDateTime *result = 0 ;
26109 void *argp1 = 0 ;
26110 int res1 = 0 ;
26111 void *argp2 = 0 ;
26112 int res2 = 0 ;
26113
26114 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26116 if (!SWIG_IsOK(res1)) {
26117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26118 }
26119 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26120 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26121 if (!SWIG_IsOK(res2)) {
26122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26123 }
26124 if (!argp2) {
26125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26126 }
26127 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26128 {
26129 PyThreadState* __tstate = wxPyBeginAllowThreads();
26130 {
26131 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26132 result = (wxDateTime *) &_result_ref;
26133 }
26134 wxPyEndAllowThreads(__tstate);
26135 if (PyErr_Occurred()) SWIG_fail;
26136 }
26137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26145 PyObject *resultobj = 0;
26146 wxDateTime *arg1 = (wxDateTime *) 0 ;
26147 wxDateSpan *arg2 = 0 ;
26148 wxDateTime *result = 0 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 void *argp2 = 0 ;
26152 int res2 = 0 ;
26153
26154 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26156 if (!SWIG_IsOK(res1)) {
26157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26158 }
26159 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26160 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26161 if (!SWIG_IsOK(res2)) {
26162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26163 }
26164 if (!argp2) {
26165 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26166 }
26167 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26168 {
26169 PyThreadState* __tstate = wxPyBeginAllowThreads();
26170 {
26171 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26172 result = (wxDateTime *) &_result_ref;
26173 }
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26178 return resultobj;
26179 fail:
26180 return NULL;
26181 }
26182
26183
26184 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26185 int argc;
26186 PyObject *argv[3];
26187
26188 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26189 --argc;
26190 if (argc == 2) {
26191 int _v = 0;
26192 {
26193 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26194 _v = SWIG_CheckState(res);
26195 }
26196 if (!_v) goto check_1;
26197 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26198 }
26199 check_1:
26200
26201 if (argc == 2) {
26202 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26203 }
26204
26205 fail:
26206 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26207 return NULL;
26208 }
26209
26210
26211 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26212 PyObject *resultobj = 0;
26213 wxDateTime *arg1 = (wxDateTime *) 0 ;
26214 wxTimeSpan *arg2 = 0 ;
26215 wxDateTime *result = 0 ;
26216 void *argp1 = 0 ;
26217 int res1 = 0 ;
26218 void *argp2 = 0 ;
26219 int res2 = 0 ;
26220
26221 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26223 if (!SWIG_IsOK(res1)) {
26224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26225 }
26226 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26227 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26228 if (!SWIG_IsOK(res2)) {
26229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26230 }
26231 if (!argp2) {
26232 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26233 }
26234 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26235 {
26236 PyThreadState* __tstate = wxPyBeginAllowThreads();
26237 {
26238 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26239 result = (wxDateTime *) &_result_ref;
26240 }
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26252 PyObject *resultobj = 0;
26253 wxDateTime *arg1 = (wxDateTime *) 0 ;
26254 wxDateSpan *arg2 = 0 ;
26255 wxDateTime *result = 0 ;
26256 void *argp1 = 0 ;
26257 int res1 = 0 ;
26258 void *argp2 = 0 ;
26259 int res2 = 0 ;
26260
26261 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26263 if (!SWIG_IsOK(res1)) {
26264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26265 }
26266 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26267 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26268 if (!SWIG_IsOK(res2)) {
26269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26270 }
26271 if (!argp2) {
26272 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26273 }
26274 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26275 {
26276 PyThreadState* __tstate = wxPyBeginAllowThreads();
26277 {
26278 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26279 result = (wxDateTime *) &_result_ref;
26280 }
26281 wxPyEndAllowThreads(__tstate);
26282 if (PyErr_Occurred()) SWIG_fail;
26283 }
26284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26285 return resultobj;
26286 fail:
26287 return NULL;
26288 }
26289
26290
26291 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26292 int argc;
26293 PyObject *argv[3];
26294
26295 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26296 --argc;
26297 if (argc == 2) {
26298 int _v = 0;
26299 {
26300 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26301 _v = SWIG_CheckState(res);
26302 }
26303 if (!_v) goto check_1;
26304 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26305 }
26306 check_1:
26307
26308 if (argc == 2) {
26309 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26310 }
26311
26312 fail:
26313 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26314 return NULL;
26315 }
26316
26317
26318 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26319 PyObject *resultobj = 0;
26320 wxDateTime *arg1 = (wxDateTime *) 0 ;
26321 wxTimeSpan *arg2 = 0 ;
26322 wxDateTime result;
26323 void *argp1 = 0 ;
26324 int res1 = 0 ;
26325 void *argp2 = 0 ;
26326 int res2 = 0 ;
26327
26328 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26330 if (!SWIG_IsOK(res1)) {
26331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26332 }
26333 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26334 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26335 if (!SWIG_IsOK(res2)) {
26336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26337 }
26338 if (!argp2) {
26339 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26340 }
26341 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26342 {
26343 PyThreadState* __tstate = wxPyBeginAllowThreads();
26344 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26345 wxPyEndAllowThreads(__tstate);
26346 if (PyErr_Occurred()) SWIG_fail;
26347 }
26348 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26349 return resultobj;
26350 fail:
26351 return NULL;
26352 }
26353
26354
26355 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26356 PyObject *resultobj = 0;
26357 wxDateTime *arg1 = (wxDateTime *) 0 ;
26358 wxDateSpan *arg2 = 0 ;
26359 wxDateTime result;
26360 void *argp1 = 0 ;
26361 int res1 = 0 ;
26362 void *argp2 = 0 ;
26363 int res2 = 0 ;
26364
26365 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26367 if (!SWIG_IsOK(res1)) {
26368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26369 }
26370 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26371 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26372 if (!SWIG_IsOK(res2)) {
26373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26374 }
26375 if (!argp2) {
26376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26377 }
26378 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26379 {
26380 PyThreadState* __tstate = wxPyBeginAllowThreads();
26381 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26382 wxPyEndAllowThreads(__tstate);
26383 if (PyErr_Occurred()) SWIG_fail;
26384 }
26385 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26386 return resultobj;
26387 fail:
26388 return NULL;
26389 }
26390
26391
26392 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26393 int argc;
26394 PyObject *argv[3];
26395
26396 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26397 --argc;
26398 if (argc == 2) {
26399 int _v = 0;
26400 {
26401 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26402 _v = SWIG_CheckState(res);
26403 }
26404 if (!_v) goto check_1;
26405 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26406 }
26407 check_1:
26408
26409 if (argc == 2) {
26410 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26411 }
26412
26413 fail:
26414 Py_INCREF(Py_NotImplemented);
26415 return Py_NotImplemented;
26416 }
26417
26418
26419 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26420 PyObject *resultobj = 0;
26421 wxDateTime *arg1 = (wxDateTime *) 0 ;
26422 wxDateTime *arg2 = 0 ;
26423 wxTimeSpan result;
26424 void *argp1 = 0 ;
26425 int res1 = 0 ;
26426 void *argp2 = 0 ;
26427 int res2 = 0 ;
26428
26429 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26431 if (!SWIG_IsOK(res1)) {
26432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26433 }
26434 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26435 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26436 if (!SWIG_IsOK(res2)) {
26437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26438 }
26439 if (!argp2) {
26440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26441 }
26442 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26446 wxPyEndAllowThreads(__tstate);
26447 if (PyErr_Occurred()) SWIG_fail;
26448 }
26449 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26450 return resultobj;
26451 fail:
26452 return NULL;
26453 }
26454
26455
26456 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26457 PyObject *resultobj = 0;
26458 wxDateTime *arg1 = (wxDateTime *) 0 ;
26459 wxTimeSpan *arg2 = 0 ;
26460 wxDateTime result;
26461 void *argp1 = 0 ;
26462 int res1 = 0 ;
26463 void *argp2 = 0 ;
26464 int res2 = 0 ;
26465
26466 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26468 if (!SWIG_IsOK(res1)) {
26469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26470 }
26471 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26472 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26473 if (!SWIG_IsOK(res2)) {
26474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26475 }
26476 if (!argp2) {
26477 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26478 }
26479 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26483 wxPyEndAllowThreads(__tstate);
26484 if (PyErr_Occurred()) SWIG_fail;
26485 }
26486 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26487 return resultobj;
26488 fail:
26489 return NULL;
26490 }
26491
26492
26493 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26494 PyObject *resultobj = 0;
26495 wxDateTime *arg1 = (wxDateTime *) 0 ;
26496 wxDateSpan *arg2 = 0 ;
26497 wxDateTime result;
26498 void *argp1 = 0 ;
26499 int res1 = 0 ;
26500 void *argp2 = 0 ;
26501 int res2 = 0 ;
26502
26503 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26505 if (!SWIG_IsOK(res1)) {
26506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26507 }
26508 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26509 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26510 if (!SWIG_IsOK(res2)) {
26511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26512 }
26513 if (!argp2) {
26514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26515 }
26516 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26517 {
26518 PyThreadState* __tstate = wxPyBeginAllowThreads();
26519 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26531 int argc;
26532 PyObject *argv[3];
26533
26534 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26535 --argc;
26536 if (argc == 2) {
26537 int _v = 0;
26538 {
26539 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26540 _v = SWIG_CheckState(res);
26541 }
26542 if (!_v) goto check_1;
26543 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26544 }
26545 check_1:
26546
26547 if (argc == 2) {
26548 int _v = 0;
26549 {
26550 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26551 _v = SWIG_CheckState(res);
26552 }
26553 if (!_v) goto check_2;
26554 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26555 }
26556 check_2:
26557
26558 if (argc == 2) {
26559 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26560 }
26561
26562 fail:
26563 Py_INCREF(Py_NotImplemented);
26564 return Py_NotImplemented;
26565 }
26566
26567
26568 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26569 PyObject *resultobj = 0;
26570 wxDateTime *arg1 = (wxDateTime *) 0 ;
26571 wxDateTime *arg2 = (wxDateTime *) 0 ;
26572 bool result;
26573 void *argp1 = 0 ;
26574 int res1 = 0 ;
26575 void *argp2 = 0 ;
26576 int res2 = 0 ;
26577 PyObject * obj0 = 0 ;
26578 PyObject * obj1 = 0 ;
26579 char * kwnames[] = {
26580 (char *) "self",(char *) "other", NULL
26581 };
26582
26583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26585 if (!SWIG_IsOK(res1)) {
26586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26587 }
26588 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26589 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26590 if (!SWIG_IsOK(res2)) {
26591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26592 }
26593 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26594 {
26595 PyThreadState* __tstate = wxPyBeginAllowThreads();
26596 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 {
26601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26602 }
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj = 0;
26611 wxDateTime *arg1 = (wxDateTime *) 0 ;
26612 wxDateTime *arg2 = (wxDateTime *) 0 ;
26613 bool result;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 void *argp2 = 0 ;
26617 int res2 = 0 ;
26618 PyObject * obj0 = 0 ;
26619 PyObject * obj1 = 0 ;
26620 char * kwnames[] = {
26621 (char *) "self",(char *) "other", NULL
26622 };
26623
26624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26626 if (!SWIG_IsOK(res1)) {
26627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26628 }
26629 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26630 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26631 if (!SWIG_IsOK(res2)) {
26632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26633 }
26634 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26638 wxPyEndAllowThreads(__tstate);
26639 if (PyErr_Occurred()) SWIG_fail;
26640 }
26641 {
26642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26643 }
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26651 PyObject *resultobj = 0;
26652 wxDateTime *arg1 = (wxDateTime *) 0 ;
26653 wxDateTime *arg2 = (wxDateTime *) 0 ;
26654 bool result;
26655 void *argp1 = 0 ;
26656 int res1 = 0 ;
26657 void *argp2 = 0 ;
26658 int res2 = 0 ;
26659 PyObject * obj0 = 0 ;
26660 PyObject * obj1 = 0 ;
26661 char * kwnames[] = {
26662 (char *) "self",(char *) "other", NULL
26663 };
26664
26665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26667 if (!SWIG_IsOK(res1)) {
26668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26669 }
26670 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26671 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26672 if (!SWIG_IsOK(res2)) {
26673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26674 }
26675 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26676 {
26677 PyThreadState* __tstate = wxPyBeginAllowThreads();
26678 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26679 wxPyEndAllowThreads(__tstate);
26680 if (PyErr_Occurred()) SWIG_fail;
26681 }
26682 {
26683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26684 }
26685 return resultobj;
26686 fail:
26687 return NULL;
26688 }
26689
26690
26691 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26692 PyObject *resultobj = 0;
26693 wxDateTime *arg1 = (wxDateTime *) 0 ;
26694 wxDateTime *arg2 = (wxDateTime *) 0 ;
26695 bool result;
26696 void *argp1 = 0 ;
26697 int res1 = 0 ;
26698 void *argp2 = 0 ;
26699 int res2 = 0 ;
26700 PyObject * obj0 = 0 ;
26701 PyObject * obj1 = 0 ;
26702 char * kwnames[] = {
26703 (char *) "self",(char *) "other", NULL
26704 };
26705
26706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26708 if (!SWIG_IsOK(res1)) {
26709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26710 }
26711 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26713 if (!SWIG_IsOK(res2)) {
26714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26715 }
26716 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26720 wxPyEndAllowThreads(__tstate);
26721 if (PyErr_Occurred()) SWIG_fail;
26722 }
26723 {
26724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26725 }
26726 return resultobj;
26727 fail:
26728 return NULL;
26729 }
26730
26731
26732 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26733 PyObject *resultobj = 0;
26734 wxDateTime *arg1 = (wxDateTime *) 0 ;
26735 wxDateTime *arg2 = (wxDateTime *) 0 ;
26736 bool result;
26737 void *argp1 = 0 ;
26738 int res1 = 0 ;
26739 void *argp2 = 0 ;
26740 int res2 = 0 ;
26741 PyObject * obj0 = 0 ;
26742 PyObject * obj1 = 0 ;
26743 char * kwnames[] = {
26744 (char *) "self",(char *) "other", NULL
26745 };
26746
26747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26749 if (!SWIG_IsOK(res1)) {
26750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26751 }
26752 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26754 if (!SWIG_IsOK(res2)) {
26755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26756 }
26757 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26758 {
26759 PyThreadState* __tstate = wxPyBeginAllowThreads();
26760 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26761 wxPyEndAllowThreads(__tstate);
26762 if (PyErr_Occurred()) SWIG_fail;
26763 }
26764 {
26765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26766 }
26767 return resultobj;
26768 fail:
26769 return NULL;
26770 }
26771
26772
26773 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26774 PyObject *resultobj = 0;
26775 wxDateTime *arg1 = (wxDateTime *) 0 ;
26776 wxDateTime *arg2 = (wxDateTime *) 0 ;
26777 bool result;
26778 void *argp1 = 0 ;
26779 int res1 = 0 ;
26780 void *argp2 = 0 ;
26781 int res2 = 0 ;
26782 PyObject * obj0 = 0 ;
26783 PyObject * obj1 = 0 ;
26784 char * kwnames[] = {
26785 (char *) "self",(char *) "other", NULL
26786 };
26787
26788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26790 if (!SWIG_IsOK(res1)) {
26791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26792 }
26793 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26794 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26795 if (!SWIG_IsOK(res2)) {
26796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26797 }
26798 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 {
26806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26807 }
26808 return resultobj;
26809 fail:
26810 return NULL;
26811 }
26812
26813
26814 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26815 PyObject *resultobj = 0;
26816 wxDateTime *arg1 = (wxDateTime *) 0 ;
26817 wxString *arg2 = 0 ;
26818 int result;
26819 void *argp1 = 0 ;
26820 int res1 = 0 ;
26821 bool temp2 = false ;
26822 PyObject * obj0 = 0 ;
26823 PyObject * obj1 = 0 ;
26824 char * kwnames[] = {
26825 (char *) "self",(char *) "date", NULL
26826 };
26827
26828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26830 if (!SWIG_IsOK(res1)) {
26831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26832 }
26833 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26834 {
26835 arg2 = wxString_in_helper(obj1);
26836 if (arg2 == NULL) SWIG_fail;
26837 temp2 = true;
26838 }
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26842 wxPyEndAllowThreads(__tstate);
26843 if (PyErr_Occurred()) SWIG_fail;
26844 }
26845 resultobj = SWIG_From_int(static_cast< int >(result));
26846 {
26847 if (temp2)
26848 delete arg2;
26849 }
26850 return resultobj;
26851 fail:
26852 {
26853 if (temp2)
26854 delete arg2;
26855 }
26856 return NULL;
26857 }
26858
26859
26860 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26861 PyObject *resultobj = 0;
26862 wxDateTime *arg1 = (wxDateTime *) 0 ;
26863 wxString *arg2 = 0 ;
26864 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26865 wxString *arg3 = (wxString *) &arg3_defvalue ;
26866 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26867 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26868 int result;
26869 void *argp1 = 0 ;
26870 int res1 = 0 ;
26871 bool temp2 = false ;
26872 bool temp3 = false ;
26873 void *argp4 = 0 ;
26874 int res4 = 0 ;
26875 PyObject * obj0 = 0 ;
26876 PyObject * obj1 = 0 ;
26877 PyObject * obj2 = 0 ;
26878 PyObject * obj3 = 0 ;
26879 char * kwnames[] = {
26880 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26881 };
26882
26883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26885 if (!SWIG_IsOK(res1)) {
26886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26887 }
26888 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26889 {
26890 arg2 = wxString_in_helper(obj1);
26891 if (arg2 == NULL) SWIG_fail;
26892 temp2 = true;
26893 }
26894 if (obj2) {
26895 {
26896 arg3 = wxString_in_helper(obj2);
26897 if (arg3 == NULL) SWIG_fail;
26898 temp3 = true;
26899 }
26900 }
26901 if (obj3) {
26902 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26903 if (!SWIG_IsOK(res4)) {
26904 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26905 }
26906 if (!argp4) {
26907 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26908 }
26909 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26910 }
26911 {
26912 PyThreadState* __tstate = wxPyBeginAllowThreads();
26913 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26914 wxPyEndAllowThreads(__tstate);
26915 if (PyErr_Occurred()) SWIG_fail;
26916 }
26917 resultobj = SWIG_From_int(static_cast< int >(result));
26918 {
26919 if (temp2)
26920 delete arg2;
26921 }
26922 {
26923 if (temp3)
26924 delete arg3;
26925 }
26926 return resultobj;
26927 fail:
26928 {
26929 if (temp2)
26930 delete arg2;
26931 }
26932 {
26933 if (temp3)
26934 delete arg3;
26935 }
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26941 PyObject *resultobj = 0;
26942 wxDateTime *arg1 = (wxDateTime *) 0 ;
26943 wxString *arg2 = 0 ;
26944 int result;
26945 void *argp1 = 0 ;
26946 int res1 = 0 ;
26947 bool temp2 = false ;
26948 PyObject * obj0 = 0 ;
26949 PyObject * obj1 = 0 ;
26950 char * kwnames[] = {
26951 (char *) "self",(char *) "datetime", NULL
26952 };
26953
26954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26956 if (!SWIG_IsOK(res1)) {
26957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26958 }
26959 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26960 {
26961 arg2 = wxString_in_helper(obj1);
26962 if (arg2 == NULL) SWIG_fail;
26963 temp2 = true;
26964 }
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 resultobj = SWIG_From_int(static_cast< int >(result));
26972 {
26973 if (temp2)
26974 delete arg2;
26975 }
26976 return resultobj;
26977 fail:
26978 {
26979 if (temp2)
26980 delete arg2;
26981 }
26982 return NULL;
26983 }
26984
26985
26986 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26987 PyObject *resultobj = 0;
26988 wxDateTime *arg1 = (wxDateTime *) 0 ;
26989 wxString *arg2 = 0 ;
26990 int result;
26991 void *argp1 = 0 ;
26992 int res1 = 0 ;
26993 bool temp2 = false ;
26994 PyObject * obj0 = 0 ;
26995 PyObject * obj1 = 0 ;
26996 char * kwnames[] = {
26997 (char *) "self",(char *) "date", NULL
26998 };
26999
27000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27002 if (!SWIG_IsOK(res1)) {
27003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27004 }
27005 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27006 {
27007 arg2 = wxString_in_helper(obj1);
27008 if (arg2 == NULL) SWIG_fail;
27009 temp2 = true;
27010 }
27011 {
27012 PyThreadState* __tstate = wxPyBeginAllowThreads();
27013 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27014 wxPyEndAllowThreads(__tstate);
27015 if (PyErr_Occurred()) SWIG_fail;
27016 }
27017 resultobj = SWIG_From_int(static_cast< int >(result));
27018 {
27019 if (temp2)
27020 delete arg2;
27021 }
27022 return resultobj;
27023 fail:
27024 {
27025 if (temp2)
27026 delete arg2;
27027 }
27028 return NULL;
27029 }
27030
27031
27032 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj = 0;
27034 wxDateTime *arg1 = (wxDateTime *) 0 ;
27035 wxString *arg2 = 0 ;
27036 int result;
27037 void *argp1 = 0 ;
27038 int res1 = 0 ;
27039 bool temp2 = false ;
27040 PyObject * obj0 = 0 ;
27041 PyObject * obj1 = 0 ;
27042 char * kwnames[] = {
27043 (char *) "self",(char *) "time", NULL
27044 };
27045
27046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27048 if (!SWIG_IsOK(res1)) {
27049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27050 }
27051 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27052 {
27053 arg2 = wxString_in_helper(obj1);
27054 if (arg2 == NULL) SWIG_fail;
27055 temp2 = true;
27056 }
27057 {
27058 PyThreadState* __tstate = wxPyBeginAllowThreads();
27059 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27060 wxPyEndAllowThreads(__tstate);
27061 if (PyErr_Occurred()) SWIG_fail;
27062 }
27063 resultobj = SWIG_From_int(static_cast< int >(result));
27064 {
27065 if (temp2)
27066 delete arg2;
27067 }
27068 return resultobj;
27069 fail:
27070 {
27071 if (temp2)
27072 delete arg2;
27073 }
27074 return NULL;
27075 }
27076
27077
27078 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27079 PyObject *resultobj = 0;
27080 wxDateTime *arg1 = (wxDateTime *) 0 ;
27081 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27082 wxString *arg2 = (wxString *) &arg2_defvalue ;
27083 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27084 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27085 wxString result;
27086 void *argp1 = 0 ;
27087 int res1 = 0 ;
27088 bool temp2 = false ;
27089 bool temp3 = false ;
27090 PyObject * obj0 = 0 ;
27091 PyObject * obj1 = 0 ;
27092 PyObject * obj2 = 0 ;
27093 char * kwnames[] = {
27094 (char *) "self",(char *) "format",(char *) "tz", NULL
27095 };
27096
27097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27099 if (!SWIG_IsOK(res1)) {
27100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27101 }
27102 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27103 if (obj1) {
27104 {
27105 arg2 = wxString_in_helper(obj1);
27106 if (arg2 == NULL) SWIG_fail;
27107 temp2 = true;
27108 }
27109 }
27110 if (obj2) {
27111 {
27112 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27113 temp3 = true;
27114 }
27115 }
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27119 wxPyEndAllowThreads(__tstate);
27120 if (PyErr_Occurred()) SWIG_fail;
27121 }
27122 {
27123 #if wxUSE_UNICODE
27124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27125 #else
27126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27127 #endif
27128 }
27129 {
27130 if (temp2)
27131 delete arg2;
27132 }
27133 {
27134 if (temp3) delete arg3;
27135 }
27136 return resultobj;
27137 fail:
27138 {
27139 if (temp2)
27140 delete arg2;
27141 }
27142 {
27143 if (temp3) delete arg3;
27144 }
27145 return NULL;
27146 }
27147
27148
27149 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27150 PyObject *resultobj = 0;
27151 wxDateTime *arg1 = (wxDateTime *) 0 ;
27152 wxString result;
27153 void *argp1 = 0 ;
27154 int res1 = 0 ;
27155 PyObject *swig_obj[1] ;
27156
27157 if (!args) SWIG_fail;
27158 swig_obj[0] = args;
27159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27160 if (!SWIG_IsOK(res1)) {
27161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27162 }
27163 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = ((wxDateTime const *)arg1)->FormatDate();
27167 wxPyEndAllowThreads(__tstate);
27168 if (PyErr_Occurred()) SWIG_fail;
27169 }
27170 {
27171 #if wxUSE_UNICODE
27172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27173 #else
27174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27175 #endif
27176 }
27177 return resultobj;
27178 fail:
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27184 PyObject *resultobj = 0;
27185 wxDateTime *arg1 = (wxDateTime *) 0 ;
27186 wxString result;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 PyObject *swig_obj[1] ;
27190
27191 if (!args) SWIG_fail;
27192 swig_obj[0] = args;
27193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27194 if (!SWIG_IsOK(res1)) {
27195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27196 }
27197 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 result = ((wxDateTime const *)arg1)->FormatTime();
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 {
27205 #if wxUSE_UNICODE
27206 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27207 #else
27208 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27209 #endif
27210 }
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27218 PyObject *resultobj = 0;
27219 wxDateTime *arg1 = (wxDateTime *) 0 ;
27220 wxString result;
27221 void *argp1 = 0 ;
27222 int res1 = 0 ;
27223 PyObject *swig_obj[1] ;
27224
27225 if (!args) SWIG_fail;
27226 swig_obj[0] = args;
27227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27228 if (!SWIG_IsOK(res1)) {
27229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27230 }
27231 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 result = ((wxDateTime const *)arg1)->FormatISODate();
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 {
27239 #if wxUSE_UNICODE
27240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27241 #else
27242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27243 #endif
27244 }
27245 return resultobj;
27246 fail:
27247 return NULL;
27248 }
27249
27250
27251 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27252 PyObject *resultobj = 0;
27253 wxDateTime *arg1 = (wxDateTime *) 0 ;
27254 wxString result;
27255 void *argp1 = 0 ;
27256 int res1 = 0 ;
27257 PyObject *swig_obj[1] ;
27258
27259 if (!args) SWIG_fail;
27260 swig_obj[0] = args;
27261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27262 if (!SWIG_IsOK(res1)) {
27263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27264 }
27265 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 result = ((wxDateTime const *)arg1)->FormatISOTime();
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 #if wxUSE_UNICODE
27274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27275 #else
27276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27277 #endif
27278 }
27279 return resultobj;
27280 fail:
27281 return NULL;
27282 }
27283
27284
27285 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27286 PyObject *obj;
27287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27288 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27289 return SWIG_Py_Void();
27290 }
27291
27292 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27293 return SWIG_Python_InitShadowInstance(args);
27294 }
27295
27296 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27297 PyObject *resultobj = 0;
27298 long arg1 ;
27299 wxTimeSpan result;
27300 long val1 ;
27301 int ecode1 = 0 ;
27302 PyObject * obj0 = 0 ;
27303 char * kwnames[] = {
27304 (char *) "ms", NULL
27305 };
27306
27307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27308 ecode1 = SWIG_AsVal_long(obj0, &val1);
27309 if (!SWIG_IsOK(ecode1)) {
27310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27311 }
27312 arg1 = static_cast< long >(val1);
27313 {
27314 PyThreadState* __tstate = wxPyBeginAllowThreads();
27315 result = wxTimeSpan::Milliseconds(arg1);
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27327 PyObject *resultobj = 0;
27328 wxTimeSpan result;
27329
27330 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = wxTimeSpan::Millisecond();
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27338 return resultobj;
27339 fail:
27340 return NULL;
27341 }
27342
27343
27344 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27345 PyObject *resultobj = 0;
27346 long arg1 ;
27347 wxTimeSpan result;
27348 long val1 ;
27349 int ecode1 = 0 ;
27350 PyObject * obj0 = 0 ;
27351 char * kwnames[] = {
27352 (char *) "sec", NULL
27353 };
27354
27355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27356 ecode1 = SWIG_AsVal_long(obj0, &val1);
27357 if (!SWIG_IsOK(ecode1)) {
27358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27359 }
27360 arg1 = static_cast< long >(val1);
27361 {
27362 PyThreadState* __tstate = wxPyBeginAllowThreads();
27363 result = wxTimeSpan::Seconds(arg1);
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27368 return resultobj;
27369 fail:
27370 return NULL;
27371 }
27372
27373
27374 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27375 PyObject *resultobj = 0;
27376 wxTimeSpan result;
27377
27378 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27379 {
27380 PyThreadState* __tstate = wxPyBeginAllowThreads();
27381 result = wxTimeSpan::Second();
27382 wxPyEndAllowThreads(__tstate);
27383 if (PyErr_Occurred()) SWIG_fail;
27384 }
27385 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27386 return resultobj;
27387 fail:
27388 return NULL;
27389 }
27390
27391
27392 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27393 PyObject *resultobj = 0;
27394 long arg1 ;
27395 wxTimeSpan result;
27396 long val1 ;
27397 int ecode1 = 0 ;
27398 PyObject * obj0 = 0 ;
27399 char * kwnames[] = {
27400 (char *) "min", NULL
27401 };
27402
27403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27404 ecode1 = SWIG_AsVal_long(obj0, &val1);
27405 if (!SWIG_IsOK(ecode1)) {
27406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27407 }
27408 arg1 = static_cast< long >(val1);
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 result = wxTimeSpan::Minutes(arg1);
27412 wxPyEndAllowThreads(__tstate);
27413 if (PyErr_Occurred()) SWIG_fail;
27414 }
27415 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27416 return resultobj;
27417 fail:
27418 return NULL;
27419 }
27420
27421
27422 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27423 PyObject *resultobj = 0;
27424 wxTimeSpan result;
27425
27426 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 result = wxTimeSpan::Minute();
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27434 return resultobj;
27435 fail:
27436 return NULL;
27437 }
27438
27439
27440 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27441 PyObject *resultobj = 0;
27442 long arg1 ;
27443 wxTimeSpan result;
27444 long val1 ;
27445 int ecode1 = 0 ;
27446 PyObject * obj0 = 0 ;
27447 char * kwnames[] = {
27448 (char *) "hours", NULL
27449 };
27450
27451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27452 ecode1 = SWIG_AsVal_long(obj0, &val1);
27453 if (!SWIG_IsOK(ecode1)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27455 }
27456 arg1 = static_cast< long >(val1);
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 result = wxTimeSpan::Hours(arg1);
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27471 PyObject *resultobj = 0;
27472 wxTimeSpan result;
27473
27474 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 result = wxTimeSpan::Hour();
27478 wxPyEndAllowThreads(__tstate);
27479 if (PyErr_Occurred()) SWIG_fail;
27480 }
27481 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27482 return resultobj;
27483 fail:
27484 return NULL;
27485 }
27486
27487
27488 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27489 PyObject *resultobj = 0;
27490 long arg1 ;
27491 wxTimeSpan result;
27492 long val1 ;
27493 int ecode1 = 0 ;
27494 PyObject * obj0 = 0 ;
27495 char * kwnames[] = {
27496 (char *) "days", NULL
27497 };
27498
27499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27500 ecode1 = SWIG_AsVal_long(obj0, &val1);
27501 if (!SWIG_IsOK(ecode1)) {
27502 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27503 }
27504 arg1 = static_cast< long >(val1);
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = wxTimeSpan::Days(arg1);
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27519 PyObject *resultobj = 0;
27520 wxTimeSpan result;
27521
27522 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 result = wxTimeSpan::Day();
27526 wxPyEndAllowThreads(__tstate);
27527 if (PyErr_Occurred()) SWIG_fail;
27528 }
27529 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27530 return resultobj;
27531 fail:
27532 return NULL;
27533 }
27534
27535
27536 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27537 PyObject *resultobj = 0;
27538 long arg1 ;
27539 wxTimeSpan result;
27540 long val1 ;
27541 int ecode1 = 0 ;
27542 PyObject * obj0 = 0 ;
27543 char * kwnames[] = {
27544 (char *) "days", NULL
27545 };
27546
27547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27548 ecode1 = SWIG_AsVal_long(obj0, &val1);
27549 if (!SWIG_IsOK(ecode1)) {
27550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27551 }
27552 arg1 = static_cast< long >(val1);
27553 {
27554 PyThreadState* __tstate = wxPyBeginAllowThreads();
27555 result = wxTimeSpan::Weeks(arg1);
27556 wxPyEndAllowThreads(__tstate);
27557 if (PyErr_Occurred()) SWIG_fail;
27558 }
27559 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27560 return resultobj;
27561 fail:
27562 return NULL;
27563 }
27564
27565
27566 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27567 PyObject *resultobj = 0;
27568 wxTimeSpan result;
27569
27570 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 result = wxTimeSpan::Week();
27574 wxPyEndAllowThreads(__tstate);
27575 if (PyErr_Occurred()) SWIG_fail;
27576 }
27577 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27578 return resultobj;
27579 fail:
27580 return NULL;
27581 }
27582
27583
27584 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27585 PyObject *resultobj = 0;
27586 long arg1 = (long) 0 ;
27587 long arg2 = (long) 0 ;
27588 long arg3 = (long) 0 ;
27589 long arg4 = (long) 0 ;
27590 wxTimeSpan *result = 0 ;
27591 long val1 ;
27592 int ecode1 = 0 ;
27593 long val2 ;
27594 int ecode2 = 0 ;
27595 long val3 ;
27596 int ecode3 = 0 ;
27597 long val4 ;
27598 int ecode4 = 0 ;
27599 PyObject * obj0 = 0 ;
27600 PyObject * obj1 = 0 ;
27601 PyObject * obj2 = 0 ;
27602 PyObject * obj3 = 0 ;
27603 char * kwnames[] = {
27604 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27605 };
27606
27607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27608 if (obj0) {
27609 ecode1 = SWIG_AsVal_long(obj0, &val1);
27610 if (!SWIG_IsOK(ecode1)) {
27611 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27612 }
27613 arg1 = static_cast< long >(val1);
27614 }
27615 if (obj1) {
27616 ecode2 = SWIG_AsVal_long(obj1, &val2);
27617 if (!SWIG_IsOK(ecode2)) {
27618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27619 }
27620 arg2 = static_cast< long >(val2);
27621 }
27622 if (obj2) {
27623 ecode3 = SWIG_AsVal_long(obj2, &val3);
27624 if (!SWIG_IsOK(ecode3)) {
27625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27626 }
27627 arg3 = static_cast< long >(val3);
27628 }
27629 if (obj3) {
27630 ecode4 = SWIG_AsVal_long(obj3, &val4);
27631 if (!SWIG_IsOK(ecode4)) {
27632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27633 }
27634 arg4 = static_cast< long >(val4);
27635 }
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27650 PyObject *resultobj = 0;
27651 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27652 void *argp1 = 0 ;
27653 int res1 = 0 ;
27654 PyObject *swig_obj[1] ;
27655
27656 if (!args) SWIG_fail;
27657 swig_obj[0] = args;
27658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27659 if (!SWIG_IsOK(res1)) {
27660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27661 }
27662 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27663 {
27664 PyThreadState* __tstate = wxPyBeginAllowThreads();
27665 delete arg1;
27666
27667 wxPyEndAllowThreads(__tstate);
27668 if (PyErr_Occurred()) SWIG_fail;
27669 }
27670 resultobj = SWIG_Py_Void();
27671 return resultobj;
27672 fail:
27673 return NULL;
27674 }
27675
27676
27677 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27678 PyObject *resultobj = 0;
27679 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27680 wxTimeSpan *arg2 = 0 ;
27681 wxTimeSpan *result = 0 ;
27682 void *argp1 = 0 ;
27683 int res1 = 0 ;
27684 void *argp2 = 0 ;
27685 int res2 = 0 ;
27686 PyObject * obj0 = 0 ;
27687 PyObject * obj1 = 0 ;
27688 char * kwnames[] = {
27689 (char *) "self",(char *) "diff", NULL
27690 };
27691
27692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27694 if (!SWIG_IsOK(res1)) {
27695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27696 }
27697 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27698 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27699 if (!SWIG_IsOK(res2)) {
27700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27701 }
27702 if (!argp2) {
27703 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27704 }
27705 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27706 {
27707 PyThreadState* __tstate = wxPyBeginAllowThreads();
27708 {
27709 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27710 result = (wxTimeSpan *) &_result_ref;
27711 }
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27723 PyObject *resultobj = 0;
27724 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27725 wxTimeSpan *arg2 = 0 ;
27726 wxTimeSpan *result = 0 ;
27727 void *argp1 = 0 ;
27728 int res1 = 0 ;
27729 void *argp2 = 0 ;
27730 int res2 = 0 ;
27731 PyObject * obj0 = 0 ;
27732 PyObject * obj1 = 0 ;
27733 char * kwnames[] = {
27734 (char *) "self",(char *) "diff", NULL
27735 };
27736
27737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27739 if (!SWIG_IsOK(res1)) {
27740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27741 }
27742 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27743 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27744 if (!SWIG_IsOK(res2)) {
27745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27746 }
27747 if (!argp2) {
27748 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27749 }
27750 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27751 {
27752 PyThreadState* __tstate = wxPyBeginAllowThreads();
27753 {
27754 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27755 result = (wxTimeSpan *) &_result_ref;
27756 }
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27768 PyObject *resultobj = 0;
27769 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27770 int arg2 ;
27771 wxTimeSpan *result = 0 ;
27772 void *argp1 = 0 ;
27773 int res1 = 0 ;
27774 int val2 ;
27775 int ecode2 = 0 ;
27776 PyObject * obj0 = 0 ;
27777 PyObject * obj1 = 0 ;
27778 char * kwnames[] = {
27779 (char *) "self",(char *) "n", NULL
27780 };
27781
27782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27784 if (!SWIG_IsOK(res1)) {
27785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27786 }
27787 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27788 ecode2 = SWIG_AsVal_int(obj1, &val2);
27789 if (!SWIG_IsOK(ecode2)) {
27790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27791 }
27792 arg2 = static_cast< int >(val2);
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 {
27796 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27797 result = (wxTimeSpan *) &_result_ref;
27798 }
27799 wxPyEndAllowThreads(__tstate);
27800 if (PyErr_Occurred()) SWIG_fail;
27801 }
27802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27803 return resultobj;
27804 fail:
27805 return NULL;
27806 }
27807
27808
27809 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 PyObject *resultobj = 0;
27811 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27812 wxTimeSpan *result = 0 ;
27813 void *argp1 = 0 ;
27814 int res1 = 0 ;
27815 PyObject *swig_obj[1] ;
27816
27817 if (!args) SWIG_fail;
27818 swig_obj[0] = args;
27819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27820 if (!SWIG_IsOK(res1)) {
27821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27822 }
27823 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 {
27827 wxTimeSpan &_result_ref = (arg1)->Neg();
27828 result = (wxTimeSpan *) &_result_ref;
27829 }
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27834 return resultobj;
27835 fail:
27836 return NULL;
27837 }
27838
27839
27840 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27841 PyObject *resultobj = 0;
27842 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27843 wxTimeSpan result;
27844 void *argp1 = 0 ;
27845 int res1 = 0 ;
27846 PyObject *swig_obj[1] ;
27847
27848 if (!args) SWIG_fail;
27849 swig_obj[0] = args;
27850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27851 if (!SWIG_IsOK(res1)) {
27852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27853 }
27854 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27855 {
27856 PyThreadState* __tstate = wxPyBeginAllowThreads();
27857 result = ((wxTimeSpan const *)arg1)->Abs();
27858 wxPyEndAllowThreads(__tstate);
27859 if (PyErr_Occurred()) SWIG_fail;
27860 }
27861 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27862 return resultobj;
27863 fail:
27864 return NULL;
27865 }
27866
27867
27868 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27869 PyObject *resultobj = 0;
27870 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27871 wxTimeSpan *arg2 = 0 ;
27872 wxTimeSpan *result = 0 ;
27873 void *argp1 = 0 ;
27874 int res1 = 0 ;
27875 void *argp2 = 0 ;
27876 int res2 = 0 ;
27877 PyObject * obj0 = 0 ;
27878 PyObject * obj1 = 0 ;
27879 char * kwnames[] = {
27880 (char *) "self",(char *) "diff", NULL
27881 };
27882
27883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27885 if (!SWIG_IsOK(res1)) {
27886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27887 }
27888 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27889 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27890 if (!SWIG_IsOK(res2)) {
27891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27892 }
27893 if (!argp2) {
27894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27895 }
27896 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27897 {
27898 PyThreadState* __tstate = wxPyBeginAllowThreads();
27899 {
27900 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27901 result = (wxTimeSpan *) &_result_ref;
27902 }
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27907 return resultobj;
27908 fail:
27909 return NULL;
27910 }
27911
27912
27913 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27914 PyObject *resultobj = 0;
27915 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27916 wxTimeSpan *arg2 = 0 ;
27917 wxTimeSpan *result = 0 ;
27918 void *argp1 = 0 ;
27919 int res1 = 0 ;
27920 void *argp2 = 0 ;
27921 int res2 = 0 ;
27922 PyObject * obj0 = 0 ;
27923 PyObject * obj1 = 0 ;
27924 char * kwnames[] = {
27925 (char *) "self",(char *) "diff", NULL
27926 };
27927
27928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27930 if (!SWIG_IsOK(res1)) {
27931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27932 }
27933 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27935 if (!SWIG_IsOK(res2)) {
27936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27937 }
27938 if (!argp2) {
27939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27940 }
27941 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 {
27945 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27946 result = (wxTimeSpan *) &_result_ref;
27947 }
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27959 PyObject *resultobj = 0;
27960 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27961 int arg2 ;
27962 wxTimeSpan *result = 0 ;
27963 void *argp1 = 0 ;
27964 int res1 = 0 ;
27965 int val2 ;
27966 int ecode2 = 0 ;
27967 PyObject * obj0 = 0 ;
27968 PyObject * obj1 = 0 ;
27969 char * kwnames[] = {
27970 (char *) "self",(char *) "n", NULL
27971 };
27972
27973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27975 if (!SWIG_IsOK(res1)) {
27976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27977 }
27978 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27979 ecode2 = SWIG_AsVal_int(obj1, &val2);
27980 if (!SWIG_IsOK(ecode2)) {
27981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
27982 }
27983 arg2 = static_cast< int >(val2);
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 {
27987 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
27988 result = (wxTimeSpan *) &_result_ref;
27989 }
27990 wxPyEndAllowThreads(__tstate);
27991 if (PyErr_Occurred()) SWIG_fail;
27992 }
27993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27994 return resultobj;
27995 fail:
27996 return NULL;
27997 }
27998
27999
28000 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28001 PyObject *resultobj = 0;
28002 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28003 wxTimeSpan *result = 0 ;
28004 void *argp1 = 0 ;
28005 int res1 = 0 ;
28006 PyObject *swig_obj[1] ;
28007
28008 if (!args) SWIG_fail;
28009 swig_obj[0] = args;
28010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28011 if (!SWIG_IsOK(res1)) {
28012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28013 }
28014 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28015 {
28016 PyThreadState* __tstate = wxPyBeginAllowThreads();
28017 {
28018 wxTimeSpan &_result_ref = (arg1)->operator -();
28019 result = (wxTimeSpan *) &_result_ref;
28020 }
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj = 0;
28033 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28034 wxTimeSpan *arg2 = 0 ;
28035 wxTimeSpan result;
28036 void *argp1 = 0 ;
28037 int res1 = 0 ;
28038 void *argp2 = 0 ;
28039 int res2 = 0 ;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 char * kwnames[] = {
28043 (char *) "self",(char *) "other", NULL
28044 };
28045
28046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28048 if (!SWIG_IsOK(res1)) {
28049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28050 }
28051 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28053 if (!SWIG_IsOK(res2)) {
28054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28055 }
28056 if (!argp2) {
28057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28058 }
28059 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28067 return resultobj;
28068 fail:
28069 return NULL;
28070 }
28071
28072
28073 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28074 PyObject *resultobj = 0;
28075 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28076 wxTimeSpan *arg2 = 0 ;
28077 wxTimeSpan result;
28078 void *argp1 = 0 ;
28079 int res1 = 0 ;
28080 void *argp2 = 0 ;
28081 int res2 = 0 ;
28082 PyObject * obj0 = 0 ;
28083 PyObject * obj1 = 0 ;
28084 char * kwnames[] = {
28085 (char *) "self",(char *) "other", NULL
28086 };
28087
28088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28090 if (!SWIG_IsOK(res1)) {
28091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28092 }
28093 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28094 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28095 if (!SWIG_IsOK(res2)) {
28096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28097 }
28098 if (!argp2) {
28099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28100 }
28101 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28102 {
28103 PyThreadState* __tstate = wxPyBeginAllowThreads();
28104 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28105 wxPyEndAllowThreads(__tstate);
28106 if (PyErr_Occurred()) SWIG_fail;
28107 }
28108 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28109 return resultobj;
28110 fail:
28111 return NULL;
28112 }
28113
28114
28115 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28116 PyObject *resultobj = 0;
28117 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28118 int arg2 ;
28119 wxTimeSpan result;
28120 void *argp1 = 0 ;
28121 int res1 = 0 ;
28122 int val2 ;
28123 int ecode2 = 0 ;
28124 PyObject * obj0 = 0 ;
28125 PyObject * obj1 = 0 ;
28126 char * kwnames[] = {
28127 (char *) "self",(char *) "n", NULL
28128 };
28129
28130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28132 if (!SWIG_IsOK(res1)) {
28133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28134 }
28135 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28136 ecode2 = SWIG_AsVal_int(obj1, &val2);
28137 if (!SWIG_IsOK(ecode2)) {
28138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28139 }
28140 arg2 = static_cast< int >(val2);
28141 {
28142 PyThreadState* __tstate = wxPyBeginAllowThreads();
28143 result = wxTimeSpan___mul__(arg1,arg2);
28144 wxPyEndAllowThreads(__tstate);
28145 if (PyErr_Occurred()) SWIG_fail;
28146 }
28147 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28148 return resultobj;
28149 fail:
28150 return NULL;
28151 }
28152
28153
28154 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28155 PyObject *resultobj = 0;
28156 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28157 int arg2 ;
28158 wxTimeSpan result;
28159 void *argp1 = 0 ;
28160 int res1 = 0 ;
28161 int val2 ;
28162 int ecode2 = 0 ;
28163 PyObject * obj0 = 0 ;
28164 PyObject * obj1 = 0 ;
28165 char * kwnames[] = {
28166 (char *) "self",(char *) "n", NULL
28167 };
28168
28169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28171 if (!SWIG_IsOK(res1)) {
28172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28173 }
28174 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28175 ecode2 = SWIG_AsVal_int(obj1, &val2);
28176 if (!SWIG_IsOK(ecode2)) {
28177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28178 }
28179 arg2 = static_cast< int >(val2);
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 result = wxTimeSpan___rmul__(arg1,arg2);
28183 wxPyEndAllowThreads(__tstate);
28184 if (PyErr_Occurred()) SWIG_fail;
28185 }
28186 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28187 return resultobj;
28188 fail:
28189 return NULL;
28190 }
28191
28192
28193 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28194 PyObject *resultobj = 0;
28195 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28196 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28197 bool result;
28198 void *argp1 = 0 ;
28199 int res1 = 0 ;
28200 void *argp2 = 0 ;
28201 int res2 = 0 ;
28202 PyObject * obj0 = 0 ;
28203 PyObject * obj1 = 0 ;
28204 char * kwnames[] = {
28205 (char *) "self",(char *) "other", NULL
28206 };
28207
28208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28210 if (!SWIG_IsOK(res1)) {
28211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28212 }
28213 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28214 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28215 if (!SWIG_IsOK(res2)) {
28216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28217 }
28218 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28219 {
28220 PyThreadState* __tstate = wxPyBeginAllowThreads();
28221 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28222 wxPyEndAllowThreads(__tstate);
28223 if (PyErr_Occurred()) SWIG_fail;
28224 }
28225 {
28226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28227 }
28228 return resultobj;
28229 fail:
28230 return NULL;
28231 }
28232
28233
28234 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28235 PyObject *resultobj = 0;
28236 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28237 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28238 bool result;
28239 void *argp1 = 0 ;
28240 int res1 = 0 ;
28241 void *argp2 = 0 ;
28242 int res2 = 0 ;
28243 PyObject * obj0 = 0 ;
28244 PyObject * obj1 = 0 ;
28245 char * kwnames[] = {
28246 (char *) "self",(char *) "other", NULL
28247 };
28248
28249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28251 if (!SWIG_IsOK(res1)) {
28252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28253 }
28254 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28256 if (!SWIG_IsOK(res2)) {
28257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28258 }
28259 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28260 {
28261 PyThreadState* __tstate = wxPyBeginAllowThreads();
28262 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28263 wxPyEndAllowThreads(__tstate);
28264 if (PyErr_Occurred()) SWIG_fail;
28265 }
28266 {
28267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28268 }
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj = 0;
28277 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28278 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28279 bool result;
28280 void *argp1 = 0 ;
28281 int res1 = 0 ;
28282 void *argp2 = 0 ;
28283 int res2 = 0 ;
28284 PyObject * obj0 = 0 ;
28285 PyObject * obj1 = 0 ;
28286 char * kwnames[] = {
28287 (char *) "self",(char *) "other", NULL
28288 };
28289
28290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28292 if (!SWIG_IsOK(res1)) {
28293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28294 }
28295 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28297 if (!SWIG_IsOK(res2)) {
28298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28299 }
28300 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28304 wxPyEndAllowThreads(__tstate);
28305 if (PyErr_Occurred()) SWIG_fail;
28306 }
28307 {
28308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28309 }
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28317 PyObject *resultobj = 0;
28318 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28319 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28320 bool result;
28321 void *argp1 = 0 ;
28322 int res1 = 0 ;
28323 void *argp2 = 0 ;
28324 int res2 = 0 ;
28325 PyObject * obj0 = 0 ;
28326 PyObject * obj1 = 0 ;
28327 char * kwnames[] = {
28328 (char *) "self",(char *) "other", NULL
28329 };
28330
28331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",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___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28335 }
28336 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28338 if (!SWIG_IsOK(res2)) {
28339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28340 }
28341 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28342 {
28343 PyThreadState* __tstate = wxPyBeginAllowThreads();
28344 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28345 wxPyEndAllowThreads(__tstate);
28346 if (PyErr_Occurred()) SWIG_fail;
28347 }
28348 {
28349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28350 }
28351 return resultobj;
28352 fail:
28353 return NULL;
28354 }
28355
28356
28357 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28358 PyObject *resultobj = 0;
28359 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28360 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28361 bool result;
28362 void *argp1 = 0 ;
28363 int res1 = 0 ;
28364 void *argp2 = 0 ;
28365 int res2 = 0 ;
28366 PyObject * obj0 = 0 ;
28367 PyObject * obj1 = 0 ;
28368 char * kwnames[] = {
28369 (char *) "self",(char *) "other", NULL
28370 };
28371
28372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28374 if (!SWIG_IsOK(res1)) {
28375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28376 }
28377 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28379 if (!SWIG_IsOK(res2)) {
28380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28381 }
28382 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28383 {
28384 PyThreadState* __tstate = wxPyBeginAllowThreads();
28385 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 {
28390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28391 }
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj = 0;
28400 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28401 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28402 bool result;
28403 void *argp1 = 0 ;
28404 int res1 = 0 ;
28405 void *argp2 = 0 ;
28406 int res2 = 0 ;
28407 PyObject * obj0 = 0 ;
28408 PyObject * obj1 = 0 ;
28409 char * kwnames[] = {
28410 (char *) "self",(char *) "other", NULL
28411 };
28412
28413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28415 if (!SWIG_IsOK(res1)) {
28416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28417 }
28418 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28420 if (!SWIG_IsOK(res2)) {
28421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28422 }
28423 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28424 {
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 {
28431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28432 }
28433 return resultobj;
28434 fail:
28435 return NULL;
28436 }
28437
28438
28439 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28440 PyObject *resultobj = 0;
28441 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28442 bool result;
28443 void *argp1 = 0 ;
28444 int res1 = 0 ;
28445 PyObject *swig_obj[1] ;
28446
28447 if (!args) SWIG_fail;
28448 swig_obj[0] = args;
28449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28450 if (!SWIG_IsOK(res1)) {
28451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28452 }
28453 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 {
28461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28462 }
28463 return resultobj;
28464 fail:
28465 return NULL;
28466 }
28467
28468
28469 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28470 PyObject *resultobj = 0;
28471 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28472 bool result;
28473 void *argp1 = 0 ;
28474 int res1 = 0 ;
28475 PyObject *swig_obj[1] ;
28476
28477 if (!args) SWIG_fail;
28478 swig_obj[0] = args;
28479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28480 if (!SWIG_IsOK(res1)) {
28481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28482 }
28483 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28487 wxPyEndAllowThreads(__tstate);
28488 if (PyErr_Occurred()) SWIG_fail;
28489 }
28490 {
28491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28492 }
28493 return resultobj;
28494 fail:
28495 return NULL;
28496 }
28497
28498
28499 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28500 PyObject *resultobj = 0;
28501 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28502 bool result;
28503 void *argp1 = 0 ;
28504 int res1 = 0 ;
28505 PyObject *swig_obj[1] ;
28506
28507 if (!args) SWIG_fail;
28508 swig_obj[0] = args;
28509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28510 if (!SWIG_IsOK(res1)) {
28511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28512 }
28513 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28514 {
28515 PyThreadState* __tstate = wxPyBeginAllowThreads();
28516 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28517 wxPyEndAllowThreads(__tstate);
28518 if (PyErr_Occurred()) SWIG_fail;
28519 }
28520 {
28521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28522 }
28523 return resultobj;
28524 fail:
28525 return NULL;
28526 }
28527
28528
28529 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28530 PyObject *resultobj = 0;
28531 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28532 wxTimeSpan *arg2 = 0 ;
28533 bool result;
28534 void *argp1 = 0 ;
28535 int res1 = 0 ;
28536 void *argp2 = 0 ;
28537 int res2 = 0 ;
28538 PyObject * obj0 = 0 ;
28539 PyObject * obj1 = 0 ;
28540 char * kwnames[] = {
28541 (char *) "self",(char *) "ts", NULL
28542 };
28543
28544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28546 if (!SWIG_IsOK(res1)) {
28547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28548 }
28549 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28550 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28551 if (!SWIG_IsOK(res2)) {
28552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28553 }
28554 if (!argp2) {
28555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28556 }
28557 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28558 {
28559 PyThreadState* __tstate = wxPyBeginAllowThreads();
28560 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 {
28565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28566 }
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28574 PyObject *resultobj = 0;
28575 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28576 wxTimeSpan *arg2 = 0 ;
28577 bool result;
28578 void *argp1 = 0 ;
28579 int res1 = 0 ;
28580 void *argp2 = 0 ;
28581 int res2 = 0 ;
28582 PyObject * obj0 = 0 ;
28583 PyObject * obj1 = 0 ;
28584 char * kwnames[] = {
28585 (char *) "self",(char *) "ts", NULL
28586 };
28587
28588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28590 if (!SWIG_IsOK(res1)) {
28591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28592 }
28593 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28595 if (!SWIG_IsOK(res2)) {
28596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28597 }
28598 if (!argp2) {
28599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28600 }
28601 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28605 wxPyEndAllowThreads(__tstate);
28606 if (PyErr_Occurred()) SWIG_fail;
28607 }
28608 {
28609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28610 }
28611 return resultobj;
28612 fail:
28613 return NULL;
28614 }
28615
28616
28617 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28618 PyObject *resultobj = 0;
28619 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28620 wxTimeSpan *arg2 = 0 ;
28621 bool result;
28622 void *argp1 = 0 ;
28623 int res1 = 0 ;
28624 void *argp2 = 0 ;
28625 int res2 = 0 ;
28626 PyObject * obj0 = 0 ;
28627 PyObject * obj1 = 0 ;
28628 char * kwnames[] = {
28629 (char *) "self",(char *) "t", NULL
28630 };
28631
28632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28634 if (!SWIG_IsOK(res1)) {
28635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28636 }
28637 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28638 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28639 if (!SWIG_IsOK(res2)) {
28640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28641 }
28642 if (!argp2) {
28643 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28644 }
28645 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28646 {
28647 PyThreadState* __tstate = wxPyBeginAllowThreads();
28648 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 {
28653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28654 }
28655 return resultobj;
28656 fail:
28657 return NULL;
28658 }
28659
28660
28661 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28662 PyObject *resultobj = 0;
28663 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28664 int result;
28665 void *argp1 = 0 ;
28666 int res1 = 0 ;
28667 PyObject *swig_obj[1] ;
28668
28669 if (!args) SWIG_fail;
28670 swig_obj[0] = args;
28671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28672 if (!SWIG_IsOK(res1)) {
28673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28674 }
28675 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28676 {
28677 PyThreadState* __tstate = wxPyBeginAllowThreads();
28678 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28679 wxPyEndAllowThreads(__tstate);
28680 if (PyErr_Occurred()) SWIG_fail;
28681 }
28682 resultobj = SWIG_From_int(static_cast< int >(result));
28683 return resultobj;
28684 fail:
28685 return NULL;
28686 }
28687
28688
28689 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28690 PyObject *resultobj = 0;
28691 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28692 int result;
28693 void *argp1 = 0 ;
28694 int res1 = 0 ;
28695 PyObject *swig_obj[1] ;
28696
28697 if (!args) SWIG_fail;
28698 swig_obj[0] = args;
28699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28700 if (!SWIG_IsOK(res1)) {
28701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28702 }
28703 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28704 {
28705 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28707 wxPyEndAllowThreads(__tstate);
28708 if (PyErr_Occurred()) SWIG_fail;
28709 }
28710 resultobj = SWIG_From_int(static_cast< int >(result));
28711 return resultobj;
28712 fail:
28713 return NULL;
28714 }
28715
28716
28717 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28718 PyObject *resultobj = 0;
28719 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28720 int result;
28721 void *argp1 = 0 ;
28722 int res1 = 0 ;
28723 PyObject *swig_obj[1] ;
28724
28725 if (!args) SWIG_fail;
28726 swig_obj[0] = args;
28727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28728 if (!SWIG_IsOK(res1)) {
28729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28730 }
28731 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 resultobj = SWIG_From_int(static_cast< int >(result));
28739 return resultobj;
28740 fail:
28741 return NULL;
28742 }
28743
28744
28745 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28746 PyObject *resultobj = 0;
28747 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28748 int result;
28749 void *argp1 = 0 ;
28750 int res1 = 0 ;
28751 PyObject *swig_obj[1] ;
28752
28753 if (!args) SWIG_fail;
28754 swig_obj[0] = args;
28755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28756 if (!SWIG_IsOK(res1)) {
28757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28758 }
28759 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28760 {
28761 PyThreadState* __tstate = wxPyBeginAllowThreads();
28762 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28763 wxPyEndAllowThreads(__tstate);
28764 if (PyErr_Occurred()) SWIG_fail;
28765 }
28766 resultobj = SWIG_From_int(static_cast< int >(result));
28767 return resultobj;
28768 fail:
28769 return NULL;
28770 }
28771
28772
28773 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28774 PyObject *resultobj = 0;
28775 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28776 wxLongLong result;
28777 void *argp1 = 0 ;
28778 int res1 = 0 ;
28779 PyObject *swig_obj[1] ;
28780
28781 if (!args) SWIG_fail;
28782 swig_obj[0] = args;
28783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28784 if (!SWIG_IsOK(res1)) {
28785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28786 }
28787 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28788 {
28789 PyThreadState* __tstate = wxPyBeginAllowThreads();
28790 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28791 wxPyEndAllowThreads(__tstate);
28792 if (PyErr_Occurred()) SWIG_fail;
28793 }
28794 {
28795 PyObject *hi, *lo, *shifter, *shifted;
28796 hi = PyLong_FromLong( (&result)->GetHi() );
28797 lo = PyLong_FromLong( (&result)->GetLo() );
28798 shifter = PyLong_FromLong(32);
28799 shifted = PyNumber_Lshift(hi, shifter);
28800 resultobj = PyNumber_Or(shifted, lo);
28801 Py_DECREF(hi);
28802 Py_DECREF(lo);
28803 Py_DECREF(shifter);
28804 Py_DECREF(shifted);
28805 }
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28813 PyObject *resultobj = 0;
28814 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28815 wxLongLong result;
28816 void *argp1 = 0 ;
28817 int res1 = 0 ;
28818 PyObject *swig_obj[1] ;
28819
28820 if (!args) SWIG_fail;
28821 swig_obj[0] = args;
28822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28823 if (!SWIG_IsOK(res1)) {
28824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28825 }
28826 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28830 wxPyEndAllowThreads(__tstate);
28831 if (PyErr_Occurred()) SWIG_fail;
28832 }
28833 {
28834 PyObject *hi, *lo, *shifter, *shifted;
28835 hi = PyLong_FromLong( (&result)->GetHi() );
28836 lo = PyLong_FromLong( (&result)->GetLo() );
28837 shifter = PyLong_FromLong(32);
28838 shifted = PyNumber_Lshift(hi, shifter);
28839 resultobj = PyNumber_Or(shifted, lo);
28840 Py_DECREF(hi);
28841 Py_DECREF(lo);
28842 Py_DECREF(shifter);
28843 Py_DECREF(shifted);
28844 }
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28852 PyObject *resultobj = 0;
28853 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28854 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28855 wxString *arg2 = (wxString *) &arg2_defvalue ;
28856 wxString result;
28857 void *argp1 = 0 ;
28858 int res1 = 0 ;
28859 bool temp2 = false ;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char * kwnames[] = {
28863 (char *) "self",(char *) "format", NULL
28864 };
28865
28866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28868 if (!SWIG_IsOK(res1)) {
28869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28870 }
28871 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28872 if (obj1) {
28873 {
28874 arg2 = wxString_in_helper(obj1);
28875 if (arg2 == NULL) SWIG_fail;
28876 temp2 = true;
28877 }
28878 }
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28882 wxPyEndAllowThreads(__tstate);
28883 if (PyErr_Occurred()) SWIG_fail;
28884 }
28885 {
28886 #if wxUSE_UNICODE
28887 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28888 #else
28889 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28890 #endif
28891 }
28892 {
28893 if (temp2)
28894 delete arg2;
28895 }
28896 return resultobj;
28897 fail:
28898 {
28899 if (temp2)
28900 delete arg2;
28901 }
28902 return NULL;
28903 }
28904
28905
28906 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28907 PyObject *obj;
28908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28909 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28910 return SWIG_Py_Void();
28911 }
28912
28913 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28914 return SWIG_Python_InitShadowInstance(args);
28915 }
28916
28917 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28918 PyObject *resultobj = 0;
28919 int arg1 = (int) 0 ;
28920 int arg2 = (int) 0 ;
28921 int arg3 = (int) 0 ;
28922 int arg4 = (int) 0 ;
28923 wxDateSpan *result = 0 ;
28924 int val1 ;
28925 int ecode1 = 0 ;
28926 int val2 ;
28927 int ecode2 = 0 ;
28928 int val3 ;
28929 int ecode3 = 0 ;
28930 int val4 ;
28931 int ecode4 = 0 ;
28932 PyObject * obj0 = 0 ;
28933 PyObject * obj1 = 0 ;
28934 PyObject * obj2 = 0 ;
28935 PyObject * obj3 = 0 ;
28936 char * kwnames[] = {
28937 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28938 };
28939
28940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28941 if (obj0) {
28942 ecode1 = SWIG_AsVal_int(obj0, &val1);
28943 if (!SWIG_IsOK(ecode1)) {
28944 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28945 }
28946 arg1 = static_cast< int >(val1);
28947 }
28948 if (obj1) {
28949 ecode2 = SWIG_AsVal_int(obj1, &val2);
28950 if (!SWIG_IsOK(ecode2)) {
28951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28952 }
28953 arg2 = static_cast< int >(val2);
28954 }
28955 if (obj2) {
28956 ecode3 = SWIG_AsVal_int(obj2, &val3);
28957 if (!SWIG_IsOK(ecode3)) {
28958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28959 }
28960 arg3 = static_cast< int >(val3);
28961 }
28962 if (obj3) {
28963 ecode4 = SWIG_AsVal_int(obj3, &val4);
28964 if (!SWIG_IsOK(ecode4)) {
28965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28966 }
28967 arg4 = static_cast< int >(val4);
28968 }
28969 {
28970 PyThreadState* __tstate = wxPyBeginAllowThreads();
28971 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28972 wxPyEndAllowThreads(__tstate);
28973 if (PyErr_Occurred()) SWIG_fail;
28974 }
28975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28976 return resultobj;
28977 fail:
28978 return NULL;
28979 }
28980
28981
28982 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28983 PyObject *resultobj = 0;
28984 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
28985 void *argp1 = 0 ;
28986 int res1 = 0 ;
28987 PyObject *swig_obj[1] ;
28988
28989 if (!args) SWIG_fail;
28990 swig_obj[0] = args;
28991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
28992 if (!SWIG_IsOK(res1)) {
28993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
28994 }
28995 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
28996 {
28997 PyThreadState* __tstate = wxPyBeginAllowThreads();
28998 delete arg1;
28999
29000 wxPyEndAllowThreads(__tstate);
29001 if (PyErr_Occurred()) SWIG_fail;
29002 }
29003 resultobj = SWIG_Py_Void();
29004 return resultobj;
29005 fail:
29006 return NULL;
29007 }
29008
29009
29010 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29011 PyObject *resultobj = 0;
29012 int arg1 ;
29013 wxDateSpan result;
29014 int val1 ;
29015 int ecode1 = 0 ;
29016 PyObject * obj0 = 0 ;
29017 char * kwnames[] = {
29018 (char *) "days", NULL
29019 };
29020
29021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29022 ecode1 = SWIG_AsVal_int(obj0, &val1);
29023 if (!SWIG_IsOK(ecode1)) {
29024 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29025 }
29026 arg1 = static_cast< int >(val1);
29027 {
29028 PyThreadState* __tstate = wxPyBeginAllowThreads();
29029 result = wxDateSpan::Days(arg1);
29030 wxPyEndAllowThreads(__tstate);
29031 if (PyErr_Occurred()) SWIG_fail;
29032 }
29033 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29034 return resultobj;
29035 fail:
29036 return NULL;
29037 }
29038
29039
29040 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29041 PyObject *resultobj = 0;
29042 wxDateSpan result;
29043
29044 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29045 {
29046 PyThreadState* __tstate = wxPyBeginAllowThreads();
29047 result = wxDateSpan::Day();
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29052 return resultobj;
29053 fail:
29054 return NULL;
29055 }
29056
29057
29058 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29059 PyObject *resultobj = 0;
29060 int arg1 ;
29061 wxDateSpan result;
29062 int val1 ;
29063 int ecode1 = 0 ;
29064 PyObject * obj0 = 0 ;
29065 char * kwnames[] = {
29066 (char *) "weeks", NULL
29067 };
29068
29069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29070 ecode1 = SWIG_AsVal_int(obj0, &val1);
29071 if (!SWIG_IsOK(ecode1)) {
29072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29073 }
29074 arg1 = static_cast< int >(val1);
29075 {
29076 PyThreadState* __tstate = wxPyBeginAllowThreads();
29077 result = wxDateSpan::Weeks(arg1);
29078 wxPyEndAllowThreads(__tstate);
29079 if (PyErr_Occurred()) SWIG_fail;
29080 }
29081 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29089 PyObject *resultobj = 0;
29090 wxDateSpan result;
29091
29092 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29093 {
29094 PyThreadState* __tstate = wxPyBeginAllowThreads();
29095 result = wxDateSpan::Week();
29096 wxPyEndAllowThreads(__tstate);
29097 if (PyErr_Occurred()) SWIG_fail;
29098 }
29099 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29100 return resultobj;
29101 fail:
29102 return NULL;
29103 }
29104
29105
29106 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29107 PyObject *resultobj = 0;
29108 int arg1 ;
29109 wxDateSpan result;
29110 int val1 ;
29111 int ecode1 = 0 ;
29112 PyObject * obj0 = 0 ;
29113 char * kwnames[] = {
29114 (char *) "mon", NULL
29115 };
29116
29117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29118 ecode1 = SWIG_AsVal_int(obj0, &val1);
29119 if (!SWIG_IsOK(ecode1)) {
29120 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29121 }
29122 arg1 = static_cast< int >(val1);
29123 {
29124 PyThreadState* __tstate = wxPyBeginAllowThreads();
29125 result = wxDateSpan::Months(arg1);
29126 wxPyEndAllowThreads(__tstate);
29127 if (PyErr_Occurred()) SWIG_fail;
29128 }
29129 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29130 return resultobj;
29131 fail:
29132 return NULL;
29133 }
29134
29135
29136 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29137 PyObject *resultobj = 0;
29138 wxDateSpan result;
29139
29140 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 result = wxDateSpan::Month();
29144 wxPyEndAllowThreads(__tstate);
29145 if (PyErr_Occurred()) SWIG_fail;
29146 }
29147 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29155 PyObject *resultobj = 0;
29156 int arg1 ;
29157 wxDateSpan result;
29158 int val1 ;
29159 int ecode1 = 0 ;
29160 PyObject * obj0 = 0 ;
29161 char * kwnames[] = {
29162 (char *) "years", NULL
29163 };
29164
29165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29166 ecode1 = SWIG_AsVal_int(obj0, &val1);
29167 if (!SWIG_IsOK(ecode1)) {
29168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29169 }
29170 arg1 = static_cast< int >(val1);
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 result = wxDateSpan::Years(arg1);
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29185 PyObject *resultobj = 0;
29186 wxDateSpan result;
29187
29188 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = wxDateSpan::Year();
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29203 PyObject *resultobj = 0;
29204 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29205 int arg2 ;
29206 wxDateSpan *result = 0 ;
29207 void *argp1 = 0 ;
29208 int res1 = 0 ;
29209 int val2 ;
29210 int ecode2 = 0 ;
29211 PyObject * obj0 = 0 ;
29212 PyObject * obj1 = 0 ;
29213 char * kwnames[] = {
29214 (char *) "self",(char *) "n", NULL
29215 };
29216
29217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29219 if (!SWIG_IsOK(res1)) {
29220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29221 }
29222 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29223 ecode2 = SWIG_AsVal_int(obj1, &val2);
29224 if (!SWIG_IsOK(ecode2)) {
29225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29226 }
29227 arg2 = static_cast< int >(val2);
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 {
29231 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29232 result = (wxDateSpan *) &_result_ref;
29233 }
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29238 return resultobj;
29239 fail:
29240 return NULL;
29241 }
29242
29243
29244 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29245 PyObject *resultobj = 0;
29246 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29247 int arg2 ;
29248 wxDateSpan *result = 0 ;
29249 void *argp1 = 0 ;
29250 int res1 = 0 ;
29251 int val2 ;
29252 int ecode2 = 0 ;
29253 PyObject * obj0 = 0 ;
29254 PyObject * obj1 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "self",(char *) "n", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29261 if (!SWIG_IsOK(res1)) {
29262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29263 }
29264 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29265 ecode2 = SWIG_AsVal_int(obj1, &val2);
29266 if (!SWIG_IsOK(ecode2)) {
29267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29268 }
29269 arg2 = static_cast< int >(val2);
29270 {
29271 PyThreadState* __tstate = wxPyBeginAllowThreads();
29272 {
29273 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29274 result = (wxDateSpan *) &_result_ref;
29275 }
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj = 0;
29288 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29289 int arg2 ;
29290 wxDateSpan *result = 0 ;
29291 void *argp1 = 0 ;
29292 int res1 = 0 ;
29293 int val2 ;
29294 int ecode2 = 0 ;
29295 PyObject * obj0 = 0 ;
29296 PyObject * obj1 = 0 ;
29297 char * kwnames[] = {
29298 (char *) "self",(char *) "n", NULL
29299 };
29300
29301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29303 if (!SWIG_IsOK(res1)) {
29304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29305 }
29306 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29307 ecode2 = SWIG_AsVal_int(obj1, &val2);
29308 if (!SWIG_IsOK(ecode2)) {
29309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29310 }
29311 arg2 = static_cast< int >(val2);
29312 {
29313 PyThreadState* __tstate = wxPyBeginAllowThreads();
29314 {
29315 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29316 result = (wxDateSpan *) &_result_ref;
29317 }
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29322 return resultobj;
29323 fail:
29324 return NULL;
29325 }
29326
29327
29328 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29329 PyObject *resultobj = 0;
29330 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29331 int arg2 ;
29332 wxDateSpan *result = 0 ;
29333 void *argp1 = 0 ;
29334 int res1 = 0 ;
29335 int val2 ;
29336 int ecode2 = 0 ;
29337 PyObject * obj0 = 0 ;
29338 PyObject * obj1 = 0 ;
29339 char * kwnames[] = {
29340 (char *) "self",(char *) "n", NULL
29341 };
29342
29343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29345 if (!SWIG_IsOK(res1)) {
29346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29347 }
29348 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29349 ecode2 = SWIG_AsVal_int(obj1, &val2);
29350 if (!SWIG_IsOK(ecode2)) {
29351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29352 }
29353 arg2 = static_cast< int >(val2);
29354 {
29355 PyThreadState* __tstate = wxPyBeginAllowThreads();
29356 {
29357 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29358 result = (wxDateSpan *) &_result_ref;
29359 }
29360 wxPyEndAllowThreads(__tstate);
29361 if (PyErr_Occurred()) SWIG_fail;
29362 }
29363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29364 return resultobj;
29365 fail:
29366 return NULL;
29367 }
29368
29369
29370 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29371 PyObject *resultobj = 0;
29372 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29373 int result;
29374 void *argp1 = 0 ;
29375 int res1 = 0 ;
29376 PyObject *swig_obj[1] ;
29377
29378 if (!args) SWIG_fail;
29379 swig_obj[0] = args;
29380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29381 if (!SWIG_IsOK(res1)) {
29382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29383 }
29384 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 result = (int)((wxDateSpan const *)arg1)->GetYears();
29388 wxPyEndAllowThreads(__tstate);
29389 if (PyErr_Occurred()) SWIG_fail;
29390 }
29391 resultobj = SWIG_From_int(static_cast< int >(result));
29392 return resultobj;
29393 fail:
29394 return NULL;
29395 }
29396
29397
29398 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29399 PyObject *resultobj = 0;
29400 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29401 int result;
29402 void *argp1 = 0 ;
29403 int res1 = 0 ;
29404 PyObject *swig_obj[1] ;
29405
29406 if (!args) SWIG_fail;
29407 swig_obj[0] = args;
29408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29409 if (!SWIG_IsOK(res1)) {
29410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29411 }
29412 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29413 {
29414 PyThreadState* __tstate = wxPyBeginAllowThreads();
29415 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29416 wxPyEndAllowThreads(__tstate);
29417 if (PyErr_Occurred()) SWIG_fail;
29418 }
29419 resultobj = SWIG_From_int(static_cast< int >(result));
29420 return resultobj;
29421 fail:
29422 return NULL;
29423 }
29424
29425
29426 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29427 PyObject *resultobj = 0;
29428 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29429 int result;
29430 void *argp1 = 0 ;
29431 int res1 = 0 ;
29432 PyObject *swig_obj[1] ;
29433
29434 if (!args) SWIG_fail;
29435 swig_obj[0] = args;
29436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29437 if (!SWIG_IsOK(res1)) {
29438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29439 }
29440 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29441 {
29442 PyThreadState* __tstate = wxPyBeginAllowThreads();
29443 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29444 wxPyEndAllowThreads(__tstate);
29445 if (PyErr_Occurred()) SWIG_fail;
29446 }
29447 resultobj = SWIG_From_int(static_cast< int >(result));
29448 return resultobj;
29449 fail:
29450 return NULL;
29451 }
29452
29453
29454 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29455 PyObject *resultobj = 0;
29456 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29457 int result;
29458 void *argp1 = 0 ;
29459 int res1 = 0 ;
29460 PyObject *swig_obj[1] ;
29461
29462 if (!args) SWIG_fail;
29463 swig_obj[0] = args;
29464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29465 if (!SWIG_IsOK(res1)) {
29466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29467 }
29468 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29469 {
29470 PyThreadState* __tstate = wxPyBeginAllowThreads();
29471 result = (int)((wxDateSpan const *)arg1)->GetDays();
29472 wxPyEndAllowThreads(__tstate);
29473 if (PyErr_Occurred()) SWIG_fail;
29474 }
29475 resultobj = SWIG_From_int(static_cast< int >(result));
29476 return resultobj;
29477 fail:
29478 return NULL;
29479 }
29480
29481
29482 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29483 PyObject *resultobj = 0;
29484 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29485 int result;
29486 void *argp1 = 0 ;
29487 int res1 = 0 ;
29488 PyObject *swig_obj[1] ;
29489
29490 if (!args) SWIG_fail;
29491 swig_obj[0] = args;
29492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29493 if (!SWIG_IsOK(res1)) {
29494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29495 }
29496 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 resultobj = SWIG_From_int(static_cast< int >(result));
29504 return resultobj;
29505 fail:
29506 return NULL;
29507 }
29508
29509
29510 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29511 PyObject *resultobj = 0;
29512 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29513 wxDateSpan *arg2 = 0 ;
29514 wxDateSpan *result = 0 ;
29515 void *argp1 = 0 ;
29516 int res1 = 0 ;
29517 void *argp2 = 0 ;
29518 int res2 = 0 ;
29519 PyObject * obj0 = 0 ;
29520 PyObject * obj1 = 0 ;
29521 char * kwnames[] = {
29522 (char *) "self",(char *) "other", NULL
29523 };
29524
29525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29527 if (!SWIG_IsOK(res1)) {
29528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29529 }
29530 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29532 if (!SWIG_IsOK(res2)) {
29533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29534 }
29535 if (!argp2) {
29536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29537 }
29538 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29539 {
29540 PyThreadState* __tstate = wxPyBeginAllowThreads();
29541 {
29542 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29543 result = (wxDateSpan *) &_result_ref;
29544 }
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29556 PyObject *resultobj = 0;
29557 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29558 wxDateSpan *arg2 = 0 ;
29559 wxDateSpan *result = 0 ;
29560 void *argp1 = 0 ;
29561 int res1 = 0 ;
29562 void *argp2 = 0 ;
29563 int res2 = 0 ;
29564 PyObject * obj0 = 0 ;
29565 PyObject * obj1 = 0 ;
29566 char * kwnames[] = {
29567 (char *) "self",(char *) "other", NULL
29568 };
29569
29570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29572 if (!SWIG_IsOK(res1)) {
29573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29574 }
29575 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29576 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29577 if (!SWIG_IsOK(res2)) {
29578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29579 }
29580 if (!argp2) {
29581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29582 }
29583 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29584 {
29585 PyThreadState* __tstate = wxPyBeginAllowThreads();
29586 {
29587 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29588 result = (wxDateSpan *) &_result_ref;
29589 }
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29594 return resultobj;
29595 fail:
29596 return NULL;
29597 }
29598
29599
29600 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29601 PyObject *resultobj = 0;
29602 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29603 wxDateSpan *result = 0 ;
29604 void *argp1 = 0 ;
29605 int res1 = 0 ;
29606 PyObject *swig_obj[1] ;
29607
29608 if (!args) SWIG_fail;
29609 swig_obj[0] = args;
29610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29611 if (!SWIG_IsOK(res1)) {
29612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29613 }
29614 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 {
29618 wxDateSpan &_result_ref = (arg1)->Neg();
29619 result = (wxDateSpan *) &_result_ref;
29620 }
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj = 0;
29633 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29634 int arg2 ;
29635 wxDateSpan *result = 0 ;
29636 void *argp1 = 0 ;
29637 int res1 = 0 ;
29638 int val2 ;
29639 int ecode2 = 0 ;
29640 PyObject * obj0 = 0 ;
29641 PyObject * obj1 = 0 ;
29642 char * kwnames[] = {
29643 (char *) "self",(char *) "factor", NULL
29644 };
29645
29646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29648 if (!SWIG_IsOK(res1)) {
29649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29650 }
29651 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29652 ecode2 = SWIG_AsVal_int(obj1, &val2);
29653 if (!SWIG_IsOK(ecode2)) {
29654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29655 }
29656 arg2 = static_cast< int >(val2);
29657 {
29658 PyThreadState* __tstate = wxPyBeginAllowThreads();
29659 {
29660 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29661 result = (wxDateSpan *) &_result_ref;
29662 }
29663 wxPyEndAllowThreads(__tstate);
29664 if (PyErr_Occurred()) SWIG_fail;
29665 }
29666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29667 return resultobj;
29668 fail:
29669 return NULL;
29670 }
29671
29672
29673 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29674 PyObject *resultobj = 0;
29675 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29676 wxDateSpan *arg2 = 0 ;
29677 wxDateSpan *result = 0 ;
29678 void *argp1 = 0 ;
29679 int res1 = 0 ;
29680 void *argp2 = 0 ;
29681 int res2 = 0 ;
29682 PyObject * obj0 = 0 ;
29683 PyObject * obj1 = 0 ;
29684 char * kwnames[] = {
29685 (char *) "self",(char *) "other", NULL
29686 };
29687
29688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29690 if (!SWIG_IsOK(res1)) {
29691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29692 }
29693 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29695 if (!SWIG_IsOK(res2)) {
29696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29697 }
29698 if (!argp2) {
29699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29700 }
29701 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29702 {
29703 PyThreadState* __tstate = wxPyBeginAllowThreads();
29704 {
29705 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29706 result = (wxDateSpan *) &_result_ref;
29707 }
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29712 return resultobj;
29713 fail:
29714 return NULL;
29715 }
29716
29717
29718 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29719 PyObject *resultobj = 0;
29720 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29721 wxDateSpan *arg2 = 0 ;
29722 wxDateSpan *result = 0 ;
29723 void *argp1 = 0 ;
29724 int res1 = 0 ;
29725 void *argp2 = 0 ;
29726 int res2 = 0 ;
29727 PyObject * obj0 = 0 ;
29728 PyObject * obj1 = 0 ;
29729 char * kwnames[] = {
29730 (char *) "self",(char *) "other", NULL
29731 };
29732
29733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29735 if (!SWIG_IsOK(res1)) {
29736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29737 }
29738 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29740 if (!SWIG_IsOK(res2)) {
29741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29742 }
29743 if (!argp2) {
29744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29745 }
29746 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29747 {
29748 PyThreadState* __tstate = wxPyBeginAllowThreads();
29749 {
29750 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29751 result = (wxDateSpan *) &_result_ref;
29752 }
29753 wxPyEndAllowThreads(__tstate);
29754 if (PyErr_Occurred()) SWIG_fail;
29755 }
29756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29757 return resultobj;
29758 fail:
29759 return NULL;
29760 }
29761
29762
29763 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29764 PyObject *resultobj = 0;
29765 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29766 wxDateSpan *result = 0 ;
29767 void *argp1 = 0 ;
29768 int res1 = 0 ;
29769 PyObject *swig_obj[1] ;
29770
29771 if (!args) SWIG_fail;
29772 swig_obj[0] = args;
29773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29774 if (!SWIG_IsOK(res1)) {
29775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29776 }
29777 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 {
29781 wxDateSpan &_result_ref = (arg1)->operator -();
29782 result = (wxDateSpan *) &_result_ref;
29783 }
29784 wxPyEndAllowThreads(__tstate);
29785 if (PyErr_Occurred()) SWIG_fail;
29786 }
29787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29795 PyObject *resultobj = 0;
29796 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29797 int arg2 ;
29798 wxDateSpan *result = 0 ;
29799 void *argp1 = 0 ;
29800 int res1 = 0 ;
29801 int val2 ;
29802 int ecode2 = 0 ;
29803 PyObject * obj0 = 0 ;
29804 PyObject * obj1 = 0 ;
29805 char * kwnames[] = {
29806 (char *) "self",(char *) "factor", NULL
29807 };
29808
29809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29811 if (!SWIG_IsOK(res1)) {
29812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29813 }
29814 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29815 ecode2 = SWIG_AsVal_int(obj1, &val2);
29816 if (!SWIG_IsOK(ecode2)) {
29817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29818 }
29819 arg2 = static_cast< int >(val2);
29820 {
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 {
29823 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29824 result = (wxDateSpan *) &_result_ref;
29825 }
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29830 return resultobj;
29831 fail:
29832 return NULL;
29833 }
29834
29835
29836 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29837 PyObject *resultobj = 0;
29838 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29839 wxDateSpan *arg2 = 0 ;
29840 wxDateSpan result;
29841 void *argp1 = 0 ;
29842 int res1 = 0 ;
29843 void *argp2 = 0 ;
29844 int res2 = 0 ;
29845 PyObject * obj0 = 0 ;
29846 PyObject * obj1 = 0 ;
29847 char * kwnames[] = {
29848 (char *) "self",(char *) "other", NULL
29849 };
29850
29851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29853 if (!SWIG_IsOK(res1)) {
29854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29855 }
29856 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29858 if (!SWIG_IsOK(res2)) {
29859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29860 }
29861 if (!argp2) {
29862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29863 }
29864 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29865 {
29866 PyThreadState* __tstate = wxPyBeginAllowThreads();
29867 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29868 wxPyEndAllowThreads(__tstate);
29869 if (PyErr_Occurred()) SWIG_fail;
29870 }
29871 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29872 return resultobj;
29873 fail:
29874 return NULL;
29875 }
29876
29877
29878 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29879 PyObject *resultobj = 0;
29880 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29881 wxDateSpan *arg2 = 0 ;
29882 wxDateSpan result;
29883 void *argp1 = 0 ;
29884 int res1 = 0 ;
29885 void *argp2 = 0 ;
29886 int res2 = 0 ;
29887 PyObject * obj0 = 0 ;
29888 PyObject * obj1 = 0 ;
29889 char * kwnames[] = {
29890 (char *) "self",(char *) "other", NULL
29891 };
29892
29893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29895 if (!SWIG_IsOK(res1)) {
29896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29897 }
29898 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29900 if (!SWIG_IsOK(res2)) {
29901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29902 }
29903 if (!argp2) {
29904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29905 }
29906 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29907 {
29908 PyThreadState* __tstate = wxPyBeginAllowThreads();
29909 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29910 wxPyEndAllowThreads(__tstate);
29911 if (PyErr_Occurred()) SWIG_fail;
29912 }
29913 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29914 return resultobj;
29915 fail:
29916 return NULL;
29917 }
29918
29919
29920 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29921 PyObject *resultobj = 0;
29922 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29923 int arg2 ;
29924 wxDateSpan result;
29925 void *argp1 = 0 ;
29926 int res1 = 0 ;
29927 int val2 ;
29928 int ecode2 = 0 ;
29929 PyObject * obj0 = 0 ;
29930 PyObject * obj1 = 0 ;
29931 char * kwnames[] = {
29932 (char *) "self",(char *) "n", NULL
29933 };
29934
29935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29937 if (!SWIG_IsOK(res1)) {
29938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29939 }
29940 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29941 ecode2 = SWIG_AsVal_int(obj1, &val2);
29942 if (!SWIG_IsOK(ecode2)) {
29943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29944 }
29945 arg2 = static_cast< int >(val2);
29946 {
29947 PyThreadState* __tstate = wxPyBeginAllowThreads();
29948 result = wxDateSpan___mul__(arg1,arg2);
29949 wxPyEndAllowThreads(__tstate);
29950 if (PyErr_Occurred()) SWIG_fail;
29951 }
29952 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29960 PyObject *resultobj = 0;
29961 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29962 int arg2 ;
29963 wxDateSpan result;
29964 void *argp1 = 0 ;
29965 int res1 = 0 ;
29966 int val2 ;
29967 int ecode2 = 0 ;
29968 PyObject * obj0 = 0 ;
29969 PyObject * obj1 = 0 ;
29970 char * kwnames[] = {
29971 (char *) "self",(char *) "n", NULL
29972 };
29973
29974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29976 if (!SWIG_IsOK(res1)) {
29977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29978 }
29979 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29980 ecode2 = SWIG_AsVal_int(obj1, &val2);
29981 if (!SWIG_IsOK(ecode2)) {
29982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29983 }
29984 arg2 = static_cast< int >(val2);
29985 {
29986 PyThreadState* __tstate = wxPyBeginAllowThreads();
29987 result = wxDateSpan___rmul__(arg1,arg2);
29988 wxPyEndAllowThreads(__tstate);
29989 if (PyErr_Occurred()) SWIG_fail;
29990 }
29991 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29992 return resultobj;
29993 fail:
29994 return NULL;
29995 }
29996
29997
29998 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29999 PyObject *resultobj = 0;
30000 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30001 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30002 bool result;
30003 void *argp1 = 0 ;
30004 int res1 = 0 ;
30005 void *argp2 = 0 ;
30006 int res2 = 0 ;
30007 PyObject * obj0 = 0 ;
30008 PyObject * obj1 = 0 ;
30009 char * kwnames[] = {
30010 (char *) "self",(char *) "other", NULL
30011 };
30012
30013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30015 if (!SWIG_IsOK(res1)) {
30016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30017 }
30018 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30020 if (!SWIG_IsOK(res2)) {
30021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30022 }
30023 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30024 {
30025 PyThreadState* __tstate = wxPyBeginAllowThreads();
30026 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30027 wxPyEndAllowThreads(__tstate);
30028 if (PyErr_Occurred()) SWIG_fail;
30029 }
30030 {
30031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30032 }
30033 return resultobj;
30034 fail:
30035 return NULL;
30036 }
30037
30038
30039 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30040 PyObject *resultobj = 0;
30041 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30042 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30043 bool result;
30044 void *argp1 = 0 ;
30045 int res1 = 0 ;
30046 void *argp2 = 0 ;
30047 int res2 = 0 ;
30048 PyObject * obj0 = 0 ;
30049 PyObject * obj1 = 0 ;
30050 char * kwnames[] = {
30051 (char *) "self",(char *) "other", NULL
30052 };
30053
30054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30056 if (!SWIG_IsOK(res1)) {
30057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30058 }
30059 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30061 if (!SWIG_IsOK(res2)) {
30062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30063 }
30064 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30065 {
30066 PyThreadState* __tstate = wxPyBeginAllowThreads();
30067 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30068 wxPyEndAllowThreads(__tstate);
30069 if (PyErr_Occurred()) SWIG_fail;
30070 }
30071 {
30072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30073 }
30074 return resultobj;
30075 fail:
30076 return NULL;
30077 }
30078
30079
30080 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30081 PyObject *obj;
30082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30083 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30084 return SWIG_Py_Void();
30085 }
30086
30087 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30088 return SWIG_Python_InitShadowInstance(args);
30089 }
30090
30091 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30092 PyObject *resultobj = 0;
30093 long result;
30094
30095 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30096 {
30097 PyThreadState* __tstate = wxPyBeginAllowThreads();
30098 result = (long)wxGetLocalTime();
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 resultobj = SWIG_From_long(static_cast< long >(result));
30103 return resultobj;
30104 fail:
30105 return NULL;
30106 }
30107
30108
30109 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30110 PyObject *resultobj = 0;
30111 long result;
30112
30113 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30114 {
30115 PyThreadState* __tstate = wxPyBeginAllowThreads();
30116 result = (long)wxGetUTCTime();
30117 wxPyEndAllowThreads(__tstate);
30118 if (PyErr_Occurred()) SWIG_fail;
30119 }
30120 resultobj = SWIG_From_long(static_cast< long >(result));
30121 return resultobj;
30122 fail:
30123 return NULL;
30124 }
30125
30126
30127 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30128 PyObject *resultobj = 0;
30129 long result;
30130
30131 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30132 {
30133 PyThreadState* __tstate = wxPyBeginAllowThreads();
30134 result = (long)wxGetCurrentTime();
30135 wxPyEndAllowThreads(__tstate);
30136 if (PyErr_Occurred()) SWIG_fail;
30137 }
30138 resultobj = SWIG_From_long(static_cast< long >(result));
30139 return resultobj;
30140 fail:
30141 return NULL;
30142 }
30143
30144
30145 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30146 PyObject *resultobj = 0;
30147 wxLongLong result;
30148
30149 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30150 {
30151 PyThreadState* __tstate = wxPyBeginAllowThreads();
30152 result = wxGetLocalTimeMillis();
30153 wxPyEndAllowThreads(__tstate);
30154 if (PyErr_Occurred()) SWIG_fail;
30155 }
30156 {
30157 PyObject *hi, *lo, *shifter, *shifted;
30158 hi = PyLong_FromLong( (&result)->GetHi() );
30159 lo = PyLong_FromLong( (&result)->GetLo() );
30160 shifter = PyLong_FromLong(32);
30161 shifted = PyNumber_Lshift(hi, shifter);
30162 resultobj = PyNumber_Or(shifted, lo);
30163 Py_DECREF(hi);
30164 Py_DECREF(lo);
30165 Py_DECREF(shifter);
30166 Py_DECREF(shifted);
30167 }
30168 return resultobj;
30169 fail:
30170 return NULL;
30171 }
30172
30173
30174 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30175 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30176 return 1;
30177 }
30178
30179
30180 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30181 PyObject *pyobj = 0;
30182
30183 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30184 return pyobj;
30185 }
30186
30187
30188 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30189 PyObject *resultobj = 0;
30190 wxDataFormatId arg1 ;
30191 wxDataFormat *result = 0 ;
30192 int val1 ;
30193 int ecode1 = 0 ;
30194 PyObject * obj0 = 0 ;
30195 char * kwnames[] = {
30196 (char *) "type", NULL
30197 };
30198
30199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30200 ecode1 = SWIG_AsVal_int(obj0, &val1);
30201 if (!SWIG_IsOK(ecode1)) {
30202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30203 }
30204 arg1 = static_cast< wxDataFormatId >(val1);
30205 {
30206 PyThreadState* __tstate = wxPyBeginAllowThreads();
30207 result = (wxDataFormat *)new wxDataFormat(arg1);
30208 wxPyEndAllowThreads(__tstate);
30209 if (PyErr_Occurred()) SWIG_fail;
30210 }
30211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30212 return resultobj;
30213 fail:
30214 return NULL;
30215 }
30216
30217
30218 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30219 PyObject *resultobj = 0;
30220 wxString *arg1 = 0 ;
30221 wxDataFormat *result = 0 ;
30222 bool temp1 = false ;
30223 PyObject * obj0 = 0 ;
30224 char * kwnames[] = {
30225 (char *) "format", NULL
30226 };
30227
30228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30229 {
30230 arg1 = wxString_in_helper(obj0);
30231 if (arg1 == NULL) SWIG_fail;
30232 temp1 = true;
30233 }
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30241 {
30242 if (temp1)
30243 delete arg1;
30244 }
30245 return resultobj;
30246 fail:
30247 {
30248 if (temp1)
30249 delete arg1;
30250 }
30251 return NULL;
30252 }
30253
30254
30255 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30256 PyObject *resultobj = 0;
30257 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30258 void *argp1 = 0 ;
30259 int res1 = 0 ;
30260 PyObject *swig_obj[1] ;
30261
30262 if (!args) SWIG_fail;
30263 swig_obj[0] = args;
30264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30265 if (!SWIG_IsOK(res1)) {
30266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30267 }
30268 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30269 {
30270 PyThreadState* __tstate = wxPyBeginAllowThreads();
30271 delete arg1;
30272
30273 wxPyEndAllowThreads(__tstate);
30274 if (PyErr_Occurred()) SWIG_fail;
30275 }
30276 resultobj = SWIG_Py_Void();
30277 return resultobj;
30278 fail:
30279 return NULL;
30280 }
30281
30282
30283 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30284 PyObject *resultobj = 0;
30285 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30286 wxDataFormatId arg2 ;
30287 bool result;
30288 void *argp1 = 0 ;
30289 int res1 = 0 ;
30290 int val2 ;
30291 int ecode2 = 0 ;
30292
30293 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30295 if (!SWIG_IsOK(res1)) {
30296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30297 }
30298 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30299 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30300 if (!SWIG_IsOK(ecode2)) {
30301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30302 }
30303 arg2 = static_cast< wxDataFormatId >(val2);
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30307 wxPyEndAllowThreads(__tstate);
30308 if (PyErr_Occurred()) SWIG_fail;
30309 }
30310 {
30311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30312 }
30313 return resultobj;
30314 fail:
30315 return NULL;
30316 }
30317
30318
30319 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30320 PyObject *resultobj = 0;
30321 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30322 wxDataFormatId arg2 ;
30323 bool result;
30324 void *argp1 = 0 ;
30325 int res1 = 0 ;
30326 int val2 ;
30327 int ecode2 = 0 ;
30328
30329 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30331 if (!SWIG_IsOK(res1)) {
30332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30333 }
30334 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30335 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30336 if (!SWIG_IsOK(ecode2)) {
30337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30338 }
30339 arg2 = static_cast< wxDataFormatId >(val2);
30340 {
30341 PyThreadState* __tstate = wxPyBeginAllowThreads();
30342 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30343 wxPyEndAllowThreads(__tstate);
30344 if (PyErr_Occurred()) SWIG_fail;
30345 }
30346 {
30347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30348 }
30349 return resultobj;
30350 fail:
30351 return NULL;
30352 }
30353
30354
30355 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30356 PyObject *resultobj = 0;
30357 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30358 wxDataFormat *arg2 = 0 ;
30359 bool result;
30360 void *argp1 = 0 ;
30361 int res1 = 0 ;
30362 void *argp2 = 0 ;
30363 int res2 = 0 ;
30364
30365 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30367 if (!SWIG_IsOK(res1)) {
30368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30369 }
30370 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30371 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30372 if (!SWIG_IsOK(res2)) {
30373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30374 }
30375 if (!argp2) {
30376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30377 }
30378 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30382 wxPyEndAllowThreads(__tstate);
30383 if (PyErr_Occurred()) SWIG_fail;
30384 }
30385 {
30386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30387 }
30388 return resultobj;
30389 fail:
30390 return NULL;
30391 }
30392
30393
30394 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30395 int argc;
30396 PyObject *argv[3];
30397
30398 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30399 --argc;
30400 if (argc == 2) {
30401 int _v = 0;
30402 {
30403 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30404 _v = SWIG_CheckState(res);
30405 }
30406 if (!_v) goto check_1;
30407 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30408 }
30409 check_1:
30410
30411 if (argc == 2) {
30412 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30413 }
30414
30415 fail:
30416 Py_INCREF(Py_NotImplemented);
30417 return Py_NotImplemented;
30418 }
30419
30420
30421 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30422 PyObject *resultobj = 0;
30423 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30424 wxDataFormat *arg2 = 0 ;
30425 bool result;
30426 void *argp1 = 0 ;
30427 int res1 = 0 ;
30428 void *argp2 = 0 ;
30429 int res2 = 0 ;
30430
30431 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30433 if (!SWIG_IsOK(res1)) {
30434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30435 }
30436 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30437 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30438 if (!SWIG_IsOK(res2)) {
30439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30440 }
30441 if (!argp2) {
30442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30443 }
30444 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30445 {
30446 PyThreadState* __tstate = wxPyBeginAllowThreads();
30447 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30448 wxPyEndAllowThreads(__tstate);
30449 if (PyErr_Occurred()) SWIG_fail;
30450 }
30451 {
30452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30453 }
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30461 int argc;
30462 PyObject *argv[3];
30463
30464 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30465 --argc;
30466 if (argc == 2) {
30467 int _v = 0;
30468 {
30469 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30470 _v = SWIG_CheckState(res);
30471 }
30472 if (!_v) goto check_1;
30473 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30474 }
30475 check_1:
30476
30477 if (argc == 2) {
30478 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30479 }
30480
30481 fail:
30482 Py_INCREF(Py_NotImplemented);
30483 return Py_NotImplemented;
30484 }
30485
30486
30487 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj = 0;
30489 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30490 wxDataFormatId arg2 ;
30491 void *argp1 = 0 ;
30492 int res1 = 0 ;
30493 int val2 ;
30494 int ecode2 = 0 ;
30495 PyObject * obj0 = 0 ;
30496 PyObject * obj1 = 0 ;
30497 char * kwnames[] = {
30498 (char *) "self",(char *) "format", NULL
30499 };
30500
30501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30503 if (!SWIG_IsOK(res1)) {
30504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30505 }
30506 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30507 ecode2 = SWIG_AsVal_int(obj1, &val2);
30508 if (!SWIG_IsOK(ecode2)) {
30509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30510 }
30511 arg2 = static_cast< wxDataFormatId >(val2);
30512 {
30513 PyThreadState* __tstate = wxPyBeginAllowThreads();
30514 (arg1)->SetType(arg2);
30515 wxPyEndAllowThreads(__tstate);
30516 if (PyErr_Occurred()) SWIG_fail;
30517 }
30518 resultobj = SWIG_Py_Void();
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30526 PyObject *resultobj = 0;
30527 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30528 wxDataFormatId result;
30529 void *argp1 = 0 ;
30530 int res1 = 0 ;
30531 PyObject *swig_obj[1] ;
30532
30533 if (!args) SWIG_fail;
30534 swig_obj[0] = args;
30535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30536 if (!SWIG_IsOK(res1)) {
30537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30538 }
30539 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 resultobj = SWIG_From_int(static_cast< int >(result));
30547 return resultobj;
30548 fail:
30549 return NULL;
30550 }
30551
30552
30553 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30554 PyObject *resultobj = 0;
30555 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30556 wxString result;
30557 void *argp1 = 0 ;
30558 int res1 = 0 ;
30559 PyObject *swig_obj[1] ;
30560
30561 if (!args) SWIG_fail;
30562 swig_obj[0] = args;
30563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30564 if (!SWIG_IsOK(res1)) {
30565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30566 }
30567 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 result = ((wxDataFormat const *)arg1)->GetId();
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 {
30575 #if wxUSE_UNICODE
30576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30577 #else
30578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30579 #endif
30580 }
30581 return resultobj;
30582 fail:
30583 return NULL;
30584 }
30585
30586
30587 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30588 PyObject *resultobj = 0;
30589 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30590 wxString *arg2 = 0 ;
30591 void *argp1 = 0 ;
30592 int res1 = 0 ;
30593 bool temp2 = false ;
30594 PyObject * obj0 = 0 ;
30595 PyObject * obj1 = 0 ;
30596 char * kwnames[] = {
30597 (char *) "self",(char *) "format", NULL
30598 };
30599
30600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30602 if (!SWIG_IsOK(res1)) {
30603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30604 }
30605 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30606 {
30607 arg2 = wxString_in_helper(obj1);
30608 if (arg2 == NULL) SWIG_fail;
30609 temp2 = true;
30610 }
30611 {
30612 PyThreadState* __tstate = wxPyBeginAllowThreads();
30613 (arg1)->SetId((wxString const &)*arg2);
30614 wxPyEndAllowThreads(__tstate);
30615 if (PyErr_Occurred()) SWIG_fail;
30616 }
30617 resultobj = SWIG_Py_Void();
30618 {
30619 if (temp2)
30620 delete arg2;
30621 }
30622 return resultobj;
30623 fail:
30624 {
30625 if (temp2)
30626 delete arg2;
30627 }
30628 return NULL;
30629 }
30630
30631
30632 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30633 PyObject *obj;
30634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30635 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30636 return SWIG_Py_Void();
30637 }
30638
30639 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30640 return SWIG_Python_InitShadowInstance(args);
30641 }
30642
30643 SWIGINTERN int FormatInvalid_set(PyObject *) {
30644 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30645 return 1;
30646 }
30647
30648
30649 SWIGINTERN PyObject *FormatInvalid_get(void) {
30650 PyObject *pyobj = 0;
30651
30652 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30653 return pyobj;
30654 }
30655
30656
30657 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30658 PyObject *resultobj = 0;
30659 wxDataObject *arg1 = (wxDataObject *) 0 ;
30660 void *argp1 = 0 ;
30661 int res1 = 0 ;
30662 PyObject *swig_obj[1] ;
30663
30664 if (!args) SWIG_fail;
30665 swig_obj[0] = args;
30666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30667 if (!SWIG_IsOK(res1)) {
30668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30669 }
30670 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 delete arg1;
30674
30675 wxPyEndAllowThreads(__tstate);
30676 if (PyErr_Occurred()) SWIG_fail;
30677 }
30678 resultobj = SWIG_Py_Void();
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30686 PyObject *resultobj = 0;
30687 wxDataObject *arg1 = (wxDataObject *) 0 ;
30688 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30689 SwigValueWrapper<wxDataFormat > result;
30690 void *argp1 = 0 ;
30691 int res1 = 0 ;
30692 int val2 ;
30693 int ecode2 = 0 ;
30694 PyObject * obj0 = 0 ;
30695 PyObject * obj1 = 0 ;
30696 char * kwnames[] = {
30697 (char *) "self",(char *) "dir", NULL
30698 };
30699
30700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30702 if (!SWIG_IsOK(res1)) {
30703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30704 }
30705 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30706 if (obj1) {
30707 ecode2 = SWIG_AsVal_int(obj1, &val2);
30708 if (!SWIG_IsOK(ecode2)) {
30709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30710 }
30711 arg2 = static_cast< wxDataObject::Direction >(val2);
30712 }
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30720 return resultobj;
30721 fail:
30722 return NULL;
30723 }
30724
30725
30726 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30727 PyObject *resultobj = 0;
30728 wxDataObject *arg1 = (wxDataObject *) 0 ;
30729 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30730 size_t result;
30731 void *argp1 = 0 ;
30732 int res1 = 0 ;
30733 int val2 ;
30734 int ecode2 = 0 ;
30735 PyObject * obj0 = 0 ;
30736 PyObject * obj1 = 0 ;
30737 char * kwnames[] = {
30738 (char *) "self",(char *) "dir", NULL
30739 };
30740
30741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30743 if (!SWIG_IsOK(res1)) {
30744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30745 }
30746 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30747 if (obj1) {
30748 ecode2 = SWIG_AsVal_int(obj1, &val2);
30749 if (!SWIG_IsOK(ecode2)) {
30750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30751 }
30752 arg2 = static_cast< wxDataObject::Direction >(val2);
30753 }
30754 {
30755 PyThreadState* __tstate = wxPyBeginAllowThreads();
30756 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30757 wxPyEndAllowThreads(__tstate);
30758 if (PyErr_Occurred()) SWIG_fail;
30759 }
30760 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30761 return resultobj;
30762 fail:
30763 return NULL;
30764 }
30765
30766
30767 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30768 PyObject *resultobj = 0;
30769 wxDataObject *arg1 = (wxDataObject *) 0 ;
30770 wxDataFormat *arg2 = 0 ;
30771 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30772 bool result;
30773 void *argp1 = 0 ;
30774 int res1 = 0 ;
30775 void *argp2 = 0 ;
30776 int res2 = 0 ;
30777 int val3 ;
30778 int ecode3 = 0 ;
30779 PyObject * obj0 = 0 ;
30780 PyObject * obj1 = 0 ;
30781 PyObject * obj2 = 0 ;
30782 char * kwnames[] = {
30783 (char *) "self",(char *) "format",(char *) "dir", NULL
30784 };
30785
30786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30788 if (!SWIG_IsOK(res1)) {
30789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30790 }
30791 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30792 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30793 if (!SWIG_IsOK(res2)) {
30794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30795 }
30796 if (!argp2) {
30797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30798 }
30799 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30800 if (obj2) {
30801 ecode3 = SWIG_AsVal_int(obj2, &val3);
30802 if (!SWIG_IsOK(ecode3)) {
30803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30804 }
30805 arg3 = static_cast< wxDataObject::Direction >(val3);
30806 }
30807 {
30808 PyThreadState* __tstate = wxPyBeginAllowThreads();
30809 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30810 wxPyEndAllowThreads(__tstate);
30811 if (PyErr_Occurred()) SWIG_fail;
30812 }
30813 {
30814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30815 }
30816 return resultobj;
30817 fail:
30818 return NULL;
30819 }
30820
30821
30822 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30823 PyObject *resultobj = 0;
30824 wxDataObject *arg1 = (wxDataObject *) 0 ;
30825 wxDataFormat *arg2 = 0 ;
30826 size_t result;
30827 void *argp1 = 0 ;
30828 int res1 = 0 ;
30829 void *argp2 = 0 ;
30830 int res2 = 0 ;
30831 PyObject * obj0 = 0 ;
30832 PyObject * obj1 = 0 ;
30833 char * kwnames[] = {
30834 (char *) "self",(char *) "format", NULL
30835 };
30836
30837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30839 if (!SWIG_IsOK(res1)) {
30840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30841 }
30842 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30843 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30844 if (!SWIG_IsOK(res2)) {
30845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30846 }
30847 if (!argp2) {
30848 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30849 }
30850 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30854 wxPyEndAllowThreads(__tstate);
30855 if (PyErr_Occurred()) SWIG_fail;
30856 }
30857 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30865 PyObject *resultobj = 0;
30866 wxDataObject *arg1 = (wxDataObject *) 0 ;
30867 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30868 PyObject *result = 0 ;
30869 void *argp1 = 0 ;
30870 int res1 = 0 ;
30871 int val2 ;
30872 int ecode2 = 0 ;
30873 PyObject * obj0 = 0 ;
30874 PyObject * obj1 = 0 ;
30875 char * kwnames[] = {
30876 (char *) "self",(char *) "dir", NULL
30877 };
30878
30879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30883 }
30884 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30885 if (obj1) {
30886 ecode2 = SWIG_AsVal_int(obj1, &val2);
30887 if (!SWIG_IsOK(ecode2)) {
30888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30889 }
30890 arg2 = static_cast< wxDataObject::Direction >(val2);
30891 }
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 resultobj = result;
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30906 PyObject *resultobj = 0;
30907 wxDataObject *arg1 = (wxDataObject *) 0 ;
30908 wxDataFormat *arg2 = 0 ;
30909 PyObject *result = 0 ;
30910 void *argp1 = 0 ;
30911 int res1 = 0 ;
30912 void *argp2 = 0 ;
30913 int res2 = 0 ;
30914 PyObject * obj0 = 0 ;
30915 PyObject * obj1 = 0 ;
30916 char * kwnames[] = {
30917 (char *) "self",(char *) "format", NULL
30918 };
30919
30920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30922 if (!SWIG_IsOK(res1)) {
30923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30924 }
30925 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30927 if (!SWIG_IsOK(res2)) {
30928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30929 }
30930 if (!argp2) {
30931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30932 }
30933 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30934 {
30935 PyThreadState* __tstate = wxPyBeginAllowThreads();
30936 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30937 wxPyEndAllowThreads(__tstate);
30938 if (PyErr_Occurred()) SWIG_fail;
30939 }
30940 resultobj = result;
30941 return resultobj;
30942 fail:
30943 return NULL;
30944 }
30945
30946
30947 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30948 PyObject *resultobj = 0;
30949 wxDataObject *arg1 = (wxDataObject *) 0 ;
30950 wxDataFormat *arg2 = 0 ;
30951 PyObject *arg3 = (PyObject *) 0 ;
30952 bool result;
30953 void *argp1 = 0 ;
30954 int res1 = 0 ;
30955 void *argp2 = 0 ;
30956 int res2 = 0 ;
30957 PyObject * obj0 = 0 ;
30958 PyObject * obj1 = 0 ;
30959 PyObject * obj2 = 0 ;
30960 char * kwnames[] = {
30961 (char *) "self",(char *) "format",(char *) "data", NULL
30962 };
30963
30964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30966 if (!SWIG_IsOK(res1)) {
30967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30968 }
30969 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30971 if (!SWIG_IsOK(res2)) {
30972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30973 }
30974 if (!argp2) {
30975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30976 }
30977 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30978 arg3 = obj2;
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
30982 wxPyEndAllowThreads(__tstate);
30983 if (PyErr_Occurred()) SWIG_fail;
30984 }
30985 {
30986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30987 }
30988 return resultobj;
30989 fail:
30990 return NULL;
30991 }
30992
30993
30994 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30995 PyObject *obj;
30996 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30997 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
30998 return SWIG_Py_Void();
30999 }
31000
31001 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31002 PyObject *resultobj = 0;
31003 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31004 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31005 wxDataObjectSimple *result = 0 ;
31006 void *argp1 = 0 ;
31007 int res1 = 0 ;
31008 PyObject * obj0 = 0 ;
31009 char * kwnames[] = {
31010 (char *) "format", NULL
31011 };
31012
31013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31014 if (obj0) {
31015 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31018 }
31019 if (!argp1) {
31020 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31021 }
31022 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31023 }
31024 {
31025 PyThreadState* __tstate = wxPyBeginAllowThreads();
31026 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31027 wxPyEndAllowThreads(__tstate);
31028 if (PyErr_Occurred()) SWIG_fail;
31029 }
31030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31031 return resultobj;
31032 fail:
31033 return NULL;
31034 }
31035
31036
31037 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31038 PyObject *resultobj = 0;
31039 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31040 wxDataFormat *result = 0 ;
31041 void *argp1 = 0 ;
31042 int res1 = 0 ;
31043 PyObject *swig_obj[1] ;
31044
31045 if (!args) SWIG_fail;
31046 swig_obj[0] = args;
31047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31048 if (!SWIG_IsOK(res1)) {
31049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31050 }
31051 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31052 {
31053 PyThreadState* __tstate = wxPyBeginAllowThreads();
31054 {
31055 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31056 result = (wxDataFormat *) &_result_ref;
31057 }
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31062 return resultobj;
31063 fail:
31064 return NULL;
31065 }
31066
31067
31068 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31069 PyObject *resultobj = 0;
31070 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31071 wxDataFormat *arg2 = 0 ;
31072 void *argp1 = 0 ;
31073 int res1 = 0 ;
31074 void *argp2 = 0 ;
31075 int res2 = 0 ;
31076 PyObject * obj0 = 0 ;
31077 PyObject * obj1 = 0 ;
31078 char * kwnames[] = {
31079 (char *) "self",(char *) "format", NULL
31080 };
31081
31082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31084 if (!SWIG_IsOK(res1)) {
31085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31086 }
31087 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31088 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31089 if (!SWIG_IsOK(res2)) {
31090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31091 }
31092 if (!argp2) {
31093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31094 }
31095 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31096 {
31097 PyThreadState* __tstate = wxPyBeginAllowThreads();
31098 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31099 wxPyEndAllowThreads(__tstate);
31100 if (PyErr_Occurred()) SWIG_fail;
31101 }
31102 resultobj = SWIG_Py_Void();
31103 return resultobj;
31104 fail:
31105 return NULL;
31106 }
31107
31108
31109 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31110 PyObject *resultobj = 0;
31111 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31112 size_t result;
31113 void *argp1 = 0 ;
31114 int res1 = 0 ;
31115 PyObject *swig_obj[1] ;
31116
31117 if (!args) SWIG_fail;
31118 swig_obj[0] = args;
31119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31120 if (!SWIG_IsOK(res1)) {
31121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31122 }
31123 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31127 wxPyEndAllowThreads(__tstate);
31128 if (PyErr_Occurred()) SWIG_fail;
31129 }
31130 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31131 return resultobj;
31132 fail:
31133 return NULL;
31134 }
31135
31136
31137 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31138 PyObject *resultobj = 0;
31139 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31140 PyObject *result = 0 ;
31141 void *argp1 = 0 ;
31142 int res1 = 0 ;
31143 PyObject *swig_obj[1] ;
31144
31145 if (!args) SWIG_fail;
31146 swig_obj[0] = args;
31147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31148 if (!SWIG_IsOK(res1)) {
31149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31150 }
31151 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31155 wxPyEndAllowThreads(__tstate);
31156 if (PyErr_Occurred()) SWIG_fail;
31157 }
31158 resultobj = result;
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31166 PyObject *resultobj = 0;
31167 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31168 PyObject *arg2 = (PyObject *) 0 ;
31169 bool result;
31170 void *argp1 = 0 ;
31171 int res1 = 0 ;
31172 PyObject * obj0 = 0 ;
31173 PyObject * obj1 = 0 ;
31174 char * kwnames[] = {
31175 (char *) "self",(char *) "data", NULL
31176 };
31177
31178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31180 if (!SWIG_IsOK(res1)) {
31181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31182 }
31183 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31184 arg2 = obj1;
31185 {
31186 PyThreadState* __tstate = wxPyBeginAllowThreads();
31187 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 {
31192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31193 }
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31201 PyObject *obj;
31202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31203 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31204 return SWIG_Py_Void();
31205 }
31206
31207 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31208 return SWIG_Python_InitShadowInstance(args);
31209 }
31210
31211 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31212 PyObject *resultobj = 0;
31213 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31214 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31215 wxPyDataObjectSimple *result = 0 ;
31216 void *argp1 = 0 ;
31217 int res1 = 0 ;
31218 PyObject * obj0 = 0 ;
31219 char * kwnames[] = {
31220 (char *) "format", NULL
31221 };
31222
31223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31224 if (obj0) {
31225 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31226 if (!SWIG_IsOK(res1)) {
31227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31228 }
31229 if (!argp1) {
31230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31231 }
31232 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31233 }
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31248 PyObject *resultobj = 0;
31249 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31250 PyObject *arg2 = (PyObject *) 0 ;
31251 PyObject *arg3 = (PyObject *) 0 ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 PyObject * obj0 = 0 ;
31255 PyObject * obj1 = 0 ;
31256 PyObject * obj2 = 0 ;
31257 char * kwnames[] = {
31258 (char *) "self",(char *) "self",(char *) "_class", NULL
31259 };
31260
31261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31263 if (!SWIG_IsOK(res1)) {
31264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31265 }
31266 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31267 arg2 = obj1;
31268 arg3 = obj2;
31269 {
31270 PyThreadState* __tstate = wxPyBeginAllowThreads();
31271 (arg1)->_setCallbackInfo(arg2,arg3);
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 resultobj = SWIG_Py_Void();
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31283 PyObject *obj;
31284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31285 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31286 return SWIG_Py_Void();
31287 }
31288
31289 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31290 return SWIG_Python_InitShadowInstance(args);
31291 }
31292
31293 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31294 PyObject *resultobj = 0;
31295 wxDataObjectComposite *result = 0 ;
31296
31297 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31298 {
31299 PyThreadState* __tstate = wxPyBeginAllowThreads();
31300 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31301 wxPyEndAllowThreads(__tstate);
31302 if (PyErr_Occurred()) SWIG_fail;
31303 }
31304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31305 return resultobj;
31306 fail:
31307 return NULL;
31308 }
31309
31310
31311 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31312 PyObject *resultobj = 0;
31313 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31314 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31315 bool arg3 = (bool) false ;
31316 void *argp1 = 0 ;
31317 int res1 = 0 ;
31318 int res2 = 0 ;
31319 bool val3 ;
31320 int ecode3 = 0 ;
31321 PyObject * obj0 = 0 ;
31322 PyObject * obj1 = 0 ;
31323 PyObject * obj2 = 0 ;
31324 char * kwnames[] = {
31325 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31326 };
31327
31328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31330 if (!SWIG_IsOK(res1)) {
31331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31332 }
31333 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31334 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31335 if (!SWIG_IsOK(res2)) {
31336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31337 }
31338 if (obj2) {
31339 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31340 if (!SWIG_IsOK(ecode3)) {
31341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31342 }
31343 arg3 = static_cast< bool >(val3);
31344 }
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 (arg1)->Add(arg2,arg3);
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_Py_Void();
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31359 PyObject *resultobj = 0;
31360 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31361 SwigValueWrapper<wxDataFormat > result;
31362 void *argp1 = 0 ;
31363 int res1 = 0 ;
31364 PyObject *swig_obj[1] ;
31365
31366 if (!args) SWIG_fail;
31367 swig_obj[0] = args;
31368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31369 if (!SWIG_IsOK(res1)) {
31370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31371 }
31372 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31373 {
31374 PyThreadState* __tstate = wxPyBeginAllowThreads();
31375 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31376 wxPyEndAllowThreads(__tstate);
31377 if (PyErr_Occurred()) SWIG_fail;
31378 }
31379 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31380 return resultobj;
31381 fail:
31382 return NULL;
31383 }
31384
31385
31386 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31387 PyObject *obj;
31388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31389 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31390 return SWIG_Py_Void();
31391 }
31392
31393 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31394 return SWIG_Python_InitShadowInstance(args);
31395 }
31396
31397 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = 0;
31399 wxString const &arg1_defvalue = wxPyEmptyString ;
31400 wxString *arg1 = (wxString *) &arg1_defvalue ;
31401 wxTextDataObject *result = 0 ;
31402 bool temp1 = false ;
31403 PyObject * obj0 = 0 ;
31404 char * kwnames[] = {
31405 (char *) "text", NULL
31406 };
31407
31408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31409 if (obj0) {
31410 {
31411 arg1 = wxString_in_helper(obj0);
31412 if (arg1 == NULL) SWIG_fail;
31413 temp1 = true;
31414 }
31415 }
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31419 wxPyEndAllowThreads(__tstate);
31420 if (PyErr_Occurred()) SWIG_fail;
31421 }
31422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31423 {
31424 if (temp1)
31425 delete arg1;
31426 }
31427 return resultobj;
31428 fail:
31429 {
31430 if (temp1)
31431 delete arg1;
31432 }
31433 return NULL;
31434 }
31435
31436
31437 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31438 PyObject *resultobj = 0;
31439 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31440 size_t result;
31441 void *argp1 = 0 ;
31442 int res1 = 0 ;
31443 PyObject *swig_obj[1] ;
31444
31445 if (!args) SWIG_fail;
31446 swig_obj[0] = args;
31447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31448 if (!SWIG_IsOK(res1)) {
31449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31450 }
31451 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31452 {
31453 PyThreadState* __tstate = wxPyBeginAllowThreads();
31454 result = (size_t)(arg1)->GetTextLength();
31455 wxPyEndAllowThreads(__tstate);
31456 if (PyErr_Occurred()) SWIG_fail;
31457 }
31458 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31459 return resultobj;
31460 fail:
31461 return NULL;
31462 }
31463
31464
31465 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31466 PyObject *resultobj = 0;
31467 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31468 wxString result;
31469 void *argp1 = 0 ;
31470 int res1 = 0 ;
31471 PyObject *swig_obj[1] ;
31472
31473 if (!args) SWIG_fail;
31474 swig_obj[0] = args;
31475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31476 if (!SWIG_IsOK(res1)) {
31477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31478 }
31479 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31480 {
31481 PyThreadState* __tstate = wxPyBeginAllowThreads();
31482 result = (arg1)->GetText();
31483 wxPyEndAllowThreads(__tstate);
31484 if (PyErr_Occurred()) SWIG_fail;
31485 }
31486 {
31487 #if wxUSE_UNICODE
31488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31489 #else
31490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31491 #endif
31492 }
31493 return resultobj;
31494 fail:
31495 return NULL;
31496 }
31497
31498
31499 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31500 PyObject *resultobj = 0;
31501 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31502 wxString *arg2 = 0 ;
31503 void *argp1 = 0 ;
31504 int res1 = 0 ;
31505 bool temp2 = false ;
31506 PyObject * obj0 = 0 ;
31507 PyObject * obj1 = 0 ;
31508 char * kwnames[] = {
31509 (char *) "self",(char *) "text", NULL
31510 };
31511
31512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31514 if (!SWIG_IsOK(res1)) {
31515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31516 }
31517 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31518 {
31519 arg2 = wxString_in_helper(obj1);
31520 if (arg2 == NULL) SWIG_fail;
31521 temp2 = true;
31522 }
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 (arg1)->SetText((wxString const &)*arg2);
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 resultobj = SWIG_Py_Void();
31530 {
31531 if (temp2)
31532 delete arg2;
31533 }
31534 return resultobj;
31535 fail:
31536 {
31537 if (temp2)
31538 delete arg2;
31539 }
31540 return NULL;
31541 }
31542
31543
31544 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31545 PyObject *obj;
31546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31547 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31548 return SWIG_Py_Void();
31549 }
31550
31551 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31552 return SWIG_Python_InitShadowInstance(args);
31553 }
31554
31555 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31556 PyObject *resultobj = 0;
31557 wxString const &arg1_defvalue = wxPyEmptyString ;
31558 wxString *arg1 = (wxString *) &arg1_defvalue ;
31559 wxPyTextDataObject *result = 0 ;
31560 bool temp1 = false ;
31561 PyObject * obj0 = 0 ;
31562 char * kwnames[] = {
31563 (char *) "text", NULL
31564 };
31565
31566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31567 if (obj0) {
31568 {
31569 arg1 = wxString_in_helper(obj0);
31570 if (arg1 == NULL) SWIG_fail;
31571 temp1 = true;
31572 }
31573 }
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31581 {
31582 if (temp1)
31583 delete arg1;
31584 }
31585 return resultobj;
31586 fail:
31587 {
31588 if (temp1)
31589 delete arg1;
31590 }
31591 return NULL;
31592 }
31593
31594
31595 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31596 PyObject *resultobj = 0;
31597 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31598 PyObject *arg2 = (PyObject *) 0 ;
31599 PyObject *arg3 = (PyObject *) 0 ;
31600 void *argp1 = 0 ;
31601 int res1 = 0 ;
31602 PyObject * obj0 = 0 ;
31603 PyObject * obj1 = 0 ;
31604 PyObject * obj2 = 0 ;
31605 char * kwnames[] = {
31606 (char *) "self",(char *) "self",(char *) "_class", NULL
31607 };
31608
31609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31611 if (!SWIG_IsOK(res1)) {
31612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31613 }
31614 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31615 arg2 = obj1;
31616 arg3 = obj2;
31617 {
31618 PyThreadState* __tstate = wxPyBeginAllowThreads();
31619 (arg1)->_setCallbackInfo(arg2,arg3);
31620 wxPyEndAllowThreads(__tstate);
31621 if (PyErr_Occurred()) SWIG_fail;
31622 }
31623 resultobj = SWIG_Py_Void();
31624 return resultobj;
31625 fail:
31626 return NULL;
31627 }
31628
31629
31630 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31631 PyObject *obj;
31632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31633 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31634 return SWIG_Py_Void();
31635 }
31636
31637 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31638 return SWIG_Python_InitShadowInstance(args);
31639 }
31640
31641 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31642 PyObject *resultobj = 0;
31643 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31644 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31645 wxBitmapDataObject *result = 0 ;
31646 void *argp1 = 0 ;
31647 int res1 = 0 ;
31648 PyObject * obj0 = 0 ;
31649 char * kwnames[] = {
31650 (char *) "bitmap", NULL
31651 };
31652
31653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31654 if (obj0) {
31655 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31656 if (!SWIG_IsOK(res1)) {
31657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31658 }
31659 if (!argp1) {
31660 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31661 }
31662 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31663 }
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31678 PyObject *resultobj = 0;
31679 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31680 wxBitmap result;
31681 void *argp1 = 0 ;
31682 int res1 = 0 ;
31683 PyObject *swig_obj[1] ;
31684
31685 if (!args) SWIG_fail;
31686 swig_obj[0] = args;
31687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31688 if (!SWIG_IsOK(res1)) {
31689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31690 }
31691 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31692 {
31693 PyThreadState* __tstate = wxPyBeginAllowThreads();
31694 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31699 return resultobj;
31700 fail:
31701 return NULL;
31702 }
31703
31704
31705 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31706 PyObject *resultobj = 0;
31707 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31708 wxBitmap *arg2 = 0 ;
31709 void *argp1 = 0 ;
31710 int res1 = 0 ;
31711 void *argp2 = 0 ;
31712 int res2 = 0 ;
31713 PyObject * obj0 = 0 ;
31714 PyObject * obj1 = 0 ;
31715 char * kwnames[] = {
31716 (char *) "self",(char *) "bitmap", NULL
31717 };
31718
31719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31721 if (!SWIG_IsOK(res1)) {
31722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31723 }
31724 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31725 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31726 if (!SWIG_IsOK(res2)) {
31727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31728 }
31729 if (!argp2) {
31730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31731 }
31732 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31733 {
31734 PyThreadState* __tstate = wxPyBeginAllowThreads();
31735 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 resultobj = SWIG_Py_Void();
31740 return resultobj;
31741 fail:
31742 return NULL;
31743 }
31744
31745
31746 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31747 PyObject *obj;
31748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31749 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31750 return SWIG_Py_Void();
31751 }
31752
31753 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31754 return SWIG_Python_InitShadowInstance(args);
31755 }
31756
31757 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31758 PyObject *resultobj = 0;
31759 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31760 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31761 wxPyBitmapDataObject *result = 0 ;
31762 void *argp1 = 0 ;
31763 int res1 = 0 ;
31764 PyObject * obj0 = 0 ;
31765 char * kwnames[] = {
31766 (char *) "bitmap", NULL
31767 };
31768
31769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31770 if (obj0) {
31771 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31772 if (!SWIG_IsOK(res1)) {
31773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31774 }
31775 if (!argp1) {
31776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31777 }
31778 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31779 }
31780 {
31781 PyThreadState* __tstate = wxPyBeginAllowThreads();
31782 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31783 wxPyEndAllowThreads(__tstate);
31784 if (PyErr_Occurred()) SWIG_fail;
31785 }
31786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31787 return resultobj;
31788 fail:
31789 return NULL;
31790 }
31791
31792
31793 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31794 PyObject *resultobj = 0;
31795 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31796 PyObject *arg2 = (PyObject *) 0 ;
31797 PyObject *arg3 = (PyObject *) 0 ;
31798 void *argp1 = 0 ;
31799 int res1 = 0 ;
31800 PyObject * obj0 = 0 ;
31801 PyObject * obj1 = 0 ;
31802 PyObject * obj2 = 0 ;
31803 char * kwnames[] = {
31804 (char *) "self",(char *) "self",(char *) "_class", NULL
31805 };
31806
31807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31809 if (!SWIG_IsOK(res1)) {
31810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31811 }
31812 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31813 arg2 = obj1;
31814 arg3 = obj2;
31815 {
31816 PyThreadState* __tstate = wxPyBeginAllowThreads();
31817 (arg1)->_setCallbackInfo(arg2,arg3);
31818 wxPyEndAllowThreads(__tstate);
31819 if (PyErr_Occurred()) SWIG_fail;
31820 }
31821 resultobj = SWIG_Py_Void();
31822 return resultobj;
31823 fail:
31824 return NULL;
31825 }
31826
31827
31828 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31829 PyObject *obj;
31830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31831 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31832 return SWIG_Py_Void();
31833 }
31834
31835 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31836 return SWIG_Python_InitShadowInstance(args);
31837 }
31838
31839 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31840 PyObject *resultobj = 0;
31841 wxFileDataObject *result = 0 ;
31842
31843 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31844 {
31845 PyThreadState* __tstate = wxPyBeginAllowThreads();
31846 result = (wxFileDataObject *)new wxFileDataObject();
31847 wxPyEndAllowThreads(__tstate);
31848 if (PyErr_Occurred()) SWIG_fail;
31849 }
31850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31851 return resultobj;
31852 fail:
31853 return NULL;
31854 }
31855
31856
31857 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31858 PyObject *resultobj = 0;
31859 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31860 wxArrayString *result = 0 ;
31861 void *argp1 = 0 ;
31862 int res1 = 0 ;
31863 PyObject *swig_obj[1] ;
31864
31865 if (!args) SWIG_fail;
31866 swig_obj[0] = args;
31867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31868 if (!SWIG_IsOK(res1)) {
31869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31870 }
31871 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31872 {
31873 PyThreadState* __tstate = wxPyBeginAllowThreads();
31874 {
31875 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31876 result = (wxArrayString *) &_result_ref;
31877 }
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 {
31882 resultobj = wxArrayString2PyList_helper(*result);
31883 }
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj = 0;
31892 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31893 wxString *arg2 = 0 ;
31894 void *argp1 = 0 ;
31895 int res1 = 0 ;
31896 bool temp2 = false ;
31897 PyObject * obj0 = 0 ;
31898 PyObject * obj1 = 0 ;
31899 char * kwnames[] = {
31900 (char *) "self",(char *) "filename", NULL
31901 };
31902
31903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31905 if (!SWIG_IsOK(res1)) {
31906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31907 }
31908 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31909 {
31910 arg2 = wxString_in_helper(obj1);
31911 if (arg2 == NULL) SWIG_fail;
31912 temp2 = true;
31913 }
31914 {
31915 PyThreadState* __tstate = wxPyBeginAllowThreads();
31916 (arg1)->AddFile((wxString const &)*arg2);
31917 wxPyEndAllowThreads(__tstate);
31918 if (PyErr_Occurred()) SWIG_fail;
31919 }
31920 resultobj = SWIG_Py_Void();
31921 {
31922 if (temp2)
31923 delete arg2;
31924 }
31925 return resultobj;
31926 fail:
31927 {
31928 if (temp2)
31929 delete arg2;
31930 }
31931 return NULL;
31932 }
31933
31934
31935 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31936 PyObject *obj;
31937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31938 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31939 return SWIG_Py_Void();
31940 }
31941
31942 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31943 return SWIG_Python_InitShadowInstance(args);
31944 }
31945
31946 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31947 PyObject *resultobj = 0;
31948 wxDataFormat *arg1 = 0 ;
31949 wxCustomDataObject *result = 0 ;
31950 void *argp1 = 0 ;
31951 int res1 = 0 ;
31952
31953 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31955 if (!SWIG_IsOK(res1)) {
31956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31957 }
31958 if (!argp1) {
31959 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31960 }
31961 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31962 {
31963 PyThreadState* __tstate = wxPyBeginAllowThreads();
31964 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31965 wxPyEndAllowThreads(__tstate);
31966 if (PyErr_Occurred()) SWIG_fail;
31967 }
31968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31969 return resultobj;
31970 fail:
31971 return NULL;
31972 }
31973
31974
31975 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31976 PyObject *resultobj = 0;
31977 wxString *arg1 = 0 ;
31978 wxCustomDataObject *result = 0 ;
31979 bool temp1 = false ;
31980
31981 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31982 {
31983 arg1 = wxString_in_helper(swig_obj[0]);
31984 if (arg1 == NULL) SWIG_fail;
31985 temp1 = true;
31986 }
31987 {
31988 PyThreadState* __tstate = wxPyBeginAllowThreads();
31989 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
31990 wxPyEndAllowThreads(__tstate);
31991 if (PyErr_Occurred()) SWIG_fail;
31992 }
31993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31994 {
31995 if (temp1)
31996 delete arg1;
31997 }
31998 return resultobj;
31999 fail:
32000 {
32001 if (temp1)
32002 delete arg1;
32003 }
32004 return NULL;
32005 }
32006
32007
32008 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32009 PyObject *resultobj = 0;
32010 wxCustomDataObject *result = 0 ;
32011
32012 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32013 {
32014 PyThreadState* __tstate = wxPyBeginAllowThreads();
32015 result = (wxCustomDataObject *)new wxCustomDataObject();
32016 wxPyEndAllowThreads(__tstate);
32017 if (PyErr_Occurred()) SWIG_fail;
32018 }
32019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32020 return resultobj;
32021 fail:
32022 return NULL;
32023 }
32024
32025
32026 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32027 int argc;
32028 PyObject *argv[2];
32029
32030 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32031 --argc;
32032 if (argc == 0) {
32033 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32034 }
32035 if (argc == 1) {
32036 int _v = 0;
32037 {
32038 {
32039 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32040 }
32041 }
32042 if (!_v) goto check_2;
32043 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32044 }
32045 check_2:
32046
32047 if (argc == 1) {
32048 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32049 }
32050
32051 fail:
32052 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32058 PyObject *resultobj = 0;
32059 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32060 PyObject *arg2 = (PyObject *) 0 ;
32061 bool result;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 PyObject * obj0 = 0 ;
32065 PyObject * obj1 = 0 ;
32066 char * kwnames[] = {
32067 (char *) "self",(char *) "data", NULL
32068 };
32069
32070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32072 if (!SWIG_IsOK(res1)) {
32073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32074 }
32075 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32076 arg2 = obj1;
32077 {
32078 PyThreadState* __tstate = wxPyBeginAllowThreads();
32079 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32080 wxPyEndAllowThreads(__tstate);
32081 if (PyErr_Occurred()) SWIG_fail;
32082 }
32083 {
32084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32085 }
32086 return resultobj;
32087 fail:
32088 return NULL;
32089 }
32090
32091
32092 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32093 PyObject *resultobj = 0;
32094 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32095 size_t result;
32096 void *argp1 = 0 ;
32097 int res1 = 0 ;
32098 PyObject *swig_obj[1] ;
32099
32100 if (!args) SWIG_fail;
32101 swig_obj[0] = args;
32102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32103 if (!SWIG_IsOK(res1)) {
32104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32105 }
32106 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32107 {
32108 PyThreadState* __tstate = wxPyBeginAllowThreads();
32109 result = (size_t)(arg1)->GetSize();
32110 wxPyEndAllowThreads(__tstate);
32111 if (PyErr_Occurred()) SWIG_fail;
32112 }
32113 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32114 return resultobj;
32115 fail:
32116 return NULL;
32117 }
32118
32119
32120 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32121 PyObject *resultobj = 0;
32122 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32123 PyObject *result = 0 ;
32124 void *argp1 = 0 ;
32125 int res1 = 0 ;
32126 PyObject *swig_obj[1] ;
32127
32128 if (!args) SWIG_fail;
32129 swig_obj[0] = args;
32130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32131 if (!SWIG_IsOK(res1)) {
32132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32133 }
32134 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32135 {
32136 PyThreadState* __tstate = wxPyBeginAllowThreads();
32137 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32138 wxPyEndAllowThreads(__tstate);
32139 if (PyErr_Occurred()) SWIG_fail;
32140 }
32141 resultobj = result;
32142 return resultobj;
32143 fail:
32144 return NULL;
32145 }
32146
32147
32148 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32149 PyObject *obj;
32150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32151 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32152 return SWIG_Py_Void();
32153 }
32154
32155 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32156 return SWIG_Python_InitShadowInstance(args);
32157 }
32158
32159 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32160 PyObject *resultobj = 0;
32161 wxURLDataObject *result = 0 ;
32162
32163 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 result = (wxURLDataObject *)new wxURLDataObject();
32167 wxPyEndAllowThreads(__tstate);
32168 if (PyErr_Occurred()) SWIG_fail;
32169 }
32170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32171 return resultobj;
32172 fail:
32173 return NULL;
32174 }
32175
32176
32177 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32178 PyObject *resultobj = 0;
32179 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32180 wxString result;
32181 void *argp1 = 0 ;
32182 int res1 = 0 ;
32183 PyObject *swig_obj[1] ;
32184
32185 if (!args) SWIG_fail;
32186 swig_obj[0] = args;
32187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32188 if (!SWIG_IsOK(res1)) {
32189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32190 }
32191 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32192 {
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (arg1)->GetURL();
32195 wxPyEndAllowThreads(__tstate);
32196 if (PyErr_Occurred()) SWIG_fail;
32197 }
32198 {
32199 #if wxUSE_UNICODE
32200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32201 #else
32202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32203 #endif
32204 }
32205 return resultobj;
32206 fail:
32207 return NULL;
32208 }
32209
32210
32211 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32212 PyObject *resultobj = 0;
32213 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32214 wxString *arg2 = 0 ;
32215 void *argp1 = 0 ;
32216 int res1 = 0 ;
32217 bool temp2 = false ;
32218 PyObject * obj0 = 0 ;
32219 PyObject * obj1 = 0 ;
32220 char * kwnames[] = {
32221 (char *) "self",(char *) "url", NULL
32222 };
32223
32224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32228 }
32229 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32230 {
32231 arg2 = wxString_in_helper(obj1);
32232 if (arg2 == NULL) SWIG_fail;
32233 temp2 = true;
32234 }
32235 {
32236 PyThreadState* __tstate = wxPyBeginAllowThreads();
32237 (arg1)->SetURL((wxString const &)*arg2);
32238 wxPyEndAllowThreads(__tstate);
32239 if (PyErr_Occurred()) SWIG_fail;
32240 }
32241 resultobj = SWIG_Py_Void();
32242 {
32243 if (temp2)
32244 delete arg2;
32245 }
32246 return resultobj;
32247 fail:
32248 {
32249 if (temp2)
32250 delete arg2;
32251 }
32252 return NULL;
32253 }
32254
32255
32256 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32257 PyObject *obj;
32258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32259 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32260 return SWIG_Py_Void();
32261 }
32262
32263 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32264 return SWIG_Python_InitShadowInstance(args);
32265 }
32266
32267 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32268 PyObject *resultobj = 0;
32269 wxMetafileDataObject *result = 0 ;
32270
32271 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32272 {
32273 PyThreadState* __tstate = wxPyBeginAllowThreads();
32274 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32275 wxPyEndAllowThreads(__tstate);
32276 if (PyErr_Occurred()) SWIG_fail;
32277 }
32278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32279 return resultobj;
32280 fail:
32281 return NULL;
32282 }
32283
32284
32285 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32286 PyObject *resultobj = 0;
32287 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32288 wxMetafile *arg2 = 0 ;
32289 void *argp1 = 0 ;
32290 int res1 = 0 ;
32291 void *argp2 = 0 ;
32292 int res2 = 0 ;
32293 PyObject * obj0 = 0 ;
32294 PyObject * obj1 = 0 ;
32295 char * kwnames[] = {
32296 (char *) "self",(char *) "metafile", NULL
32297 };
32298
32299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32301 if (!SWIG_IsOK(res1)) {
32302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32303 }
32304 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32305 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32306 if (!SWIG_IsOK(res2)) {
32307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32308 }
32309 if (!argp2) {
32310 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32311 }
32312 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32316 wxPyEndAllowThreads(__tstate);
32317 if (PyErr_Occurred()) SWIG_fail;
32318 }
32319 resultobj = SWIG_Py_Void();
32320 return resultobj;
32321 fail:
32322 return NULL;
32323 }
32324
32325
32326 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32327 PyObject *resultobj = 0;
32328 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32329 wxMetafile result;
32330 void *argp1 = 0 ;
32331 int res1 = 0 ;
32332 PyObject *swig_obj[1] ;
32333
32334 if (!args) SWIG_fail;
32335 swig_obj[0] = args;
32336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32337 if (!SWIG_IsOK(res1)) {
32338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32339 }
32340 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32341 {
32342 PyThreadState* __tstate = wxPyBeginAllowThreads();
32343 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32344 wxPyEndAllowThreads(__tstate);
32345 if (PyErr_Occurred()) SWIG_fail;
32346 }
32347 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32348 return resultobj;
32349 fail:
32350 return NULL;
32351 }
32352
32353
32354 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32355 PyObject *obj;
32356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32357 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32358 return SWIG_Py_Void();
32359 }
32360
32361 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32362 return SWIG_Python_InitShadowInstance(args);
32363 }
32364
32365 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32366 PyObject *resultobj = 0;
32367 wxDragResult arg1 ;
32368 bool result;
32369 int val1 ;
32370 int ecode1 = 0 ;
32371 PyObject * obj0 = 0 ;
32372 char * kwnames[] = {
32373 (char *) "res", NULL
32374 };
32375
32376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32377 ecode1 = SWIG_AsVal_int(obj0, &val1);
32378 if (!SWIG_IsOK(ecode1)) {
32379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32380 }
32381 arg1 = static_cast< wxDragResult >(val1);
32382 {
32383 PyThreadState* __tstate = wxPyBeginAllowThreads();
32384 result = (bool)wxIsDragResultOk(arg1);
32385 wxPyEndAllowThreads(__tstate);
32386 if (PyErr_Occurred()) SWIG_fail;
32387 }
32388 {
32389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32390 }
32391 return resultobj;
32392 fail:
32393 return NULL;
32394 }
32395
32396
32397 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32398 PyObject *resultobj = 0;
32399 wxWindow *arg1 = (wxWindow *) 0 ;
32400 wxCursor const &arg2_defvalue = wxNullCursor ;
32401 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32402 wxCursor const &arg3_defvalue = wxNullCursor ;
32403 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32404 wxCursor const &arg4_defvalue = wxNullCursor ;
32405 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32406 wxPyDropSource *result = 0 ;
32407 void *argp1 = 0 ;
32408 int res1 = 0 ;
32409 void *argp2 = 0 ;
32410 int res2 = 0 ;
32411 void *argp3 = 0 ;
32412 int res3 = 0 ;
32413 void *argp4 = 0 ;
32414 int res4 = 0 ;
32415 PyObject * obj0 = 0 ;
32416 PyObject * obj1 = 0 ;
32417 PyObject * obj2 = 0 ;
32418 PyObject * obj3 = 0 ;
32419 char * kwnames[] = {
32420 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32421 };
32422
32423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32425 if (!SWIG_IsOK(res1)) {
32426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32427 }
32428 arg1 = reinterpret_cast< wxWindow * >(argp1);
32429 if (obj1) {
32430 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32431 if (!SWIG_IsOK(res2)) {
32432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32433 }
32434 if (!argp2) {
32435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32436 }
32437 arg2 = reinterpret_cast< wxCursor * >(argp2);
32438 }
32439 if (obj2) {
32440 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32441 if (!SWIG_IsOK(res3)) {
32442 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32443 }
32444 if (!argp3) {
32445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32446 }
32447 arg3 = reinterpret_cast< wxCursor * >(argp3);
32448 }
32449 if (obj3) {
32450 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32451 if (!SWIG_IsOK(res4)) {
32452 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32453 }
32454 if (!argp4) {
32455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32456 }
32457 arg4 = reinterpret_cast< wxCursor * >(argp4);
32458 }
32459 {
32460 PyThreadState* __tstate = wxPyBeginAllowThreads();
32461 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32462 wxPyEndAllowThreads(__tstate);
32463 if (PyErr_Occurred()) SWIG_fail;
32464 }
32465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32466 return resultobj;
32467 fail:
32468 return NULL;
32469 }
32470
32471
32472 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32473 PyObject *resultobj = 0;
32474 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32475 PyObject *arg2 = (PyObject *) 0 ;
32476 PyObject *arg3 = (PyObject *) 0 ;
32477 int arg4 ;
32478 void *argp1 = 0 ;
32479 int res1 = 0 ;
32480 int val4 ;
32481 int ecode4 = 0 ;
32482 PyObject * obj0 = 0 ;
32483 PyObject * obj1 = 0 ;
32484 PyObject * obj2 = 0 ;
32485 PyObject * obj3 = 0 ;
32486 char * kwnames[] = {
32487 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32488 };
32489
32490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32492 if (!SWIG_IsOK(res1)) {
32493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32494 }
32495 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32496 arg2 = obj1;
32497 arg3 = obj2;
32498 ecode4 = SWIG_AsVal_int(obj3, &val4);
32499 if (!SWIG_IsOK(ecode4)) {
32500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32501 }
32502 arg4 = static_cast< int >(val4);
32503 {
32504 PyThreadState* __tstate = wxPyBeginAllowThreads();
32505 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32506 wxPyEndAllowThreads(__tstate);
32507 if (PyErr_Occurred()) SWIG_fail;
32508 }
32509 resultobj = SWIG_Py_Void();
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *resultobj = 0;
32518 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 PyObject *swig_obj[1] ;
32522
32523 if (!args) SWIG_fail;
32524 swig_obj[0] = args;
32525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32526 if (!SWIG_IsOK(res1)) {
32527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32528 }
32529 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 delete arg1;
32533
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 resultobj = SWIG_Py_Void();
32538 return resultobj;
32539 fail:
32540 return NULL;
32541 }
32542
32543
32544 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32545 PyObject *resultobj = 0;
32546 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32547 wxDataObject *arg2 = 0 ;
32548 void *argp1 = 0 ;
32549 int res1 = 0 ;
32550 void *argp2 = 0 ;
32551 int res2 = 0 ;
32552 PyObject * obj0 = 0 ;
32553 PyObject * obj1 = 0 ;
32554 char * kwnames[] = {
32555 (char *) "self",(char *) "data", NULL
32556 };
32557
32558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32560 if (!SWIG_IsOK(res1)) {
32561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32562 }
32563 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32565 if (!SWIG_IsOK(res2)) {
32566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32567 }
32568 if (!argp2) {
32569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32570 }
32571 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32572 {
32573 PyThreadState* __tstate = wxPyBeginAllowThreads();
32574 (arg1)->SetData(*arg2);
32575 wxPyEndAllowThreads(__tstate);
32576 if (PyErr_Occurred()) SWIG_fail;
32577 }
32578 resultobj = SWIG_Py_Void();
32579 return resultobj;
32580 fail:
32581 return NULL;
32582 }
32583
32584
32585 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32586 PyObject *resultobj = 0;
32587 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32588 wxDataObject *result = 0 ;
32589 void *argp1 = 0 ;
32590 int res1 = 0 ;
32591 PyObject *swig_obj[1] ;
32592
32593 if (!args) SWIG_fail;
32594 swig_obj[0] = args;
32595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32596 if (!SWIG_IsOK(res1)) {
32597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32598 }
32599 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32600 {
32601 PyThreadState* __tstate = wxPyBeginAllowThreads();
32602 result = (wxDataObject *)(arg1)->GetDataObject();
32603 wxPyEndAllowThreads(__tstate);
32604 if (PyErr_Occurred()) SWIG_fail;
32605 }
32606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32607 return resultobj;
32608 fail:
32609 return NULL;
32610 }
32611
32612
32613 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32614 PyObject *resultobj = 0;
32615 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32616 wxDragResult arg2 ;
32617 wxCursor *arg3 = 0 ;
32618 void *argp1 = 0 ;
32619 int res1 = 0 ;
32620 int val2 ;
32621 int ecode2 = 0 ;
32622 void *argp3 = 0 ;
32623 int res3 = 0 ;
32624 PyObject * obj0 = 0 ;
32625 PyObject * obj1 = 0 ;
32626 PyObject * obj2 = 0 ;
32627 char * kwnames[] = {
32628 (char *) "self",(char *) "res",(char *) "cursor", NULL
32629 };
32630
32631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32633 if (!SWIG_IsOK(res1)) {
32634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32635 }
32636 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32637 ecode2 = SWIG_AsVal_int(obj1, &val2);
32638 if (!SWIG_IsOK(ecode2)) {
32639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32640 }
32641 arg2 = static_cast< wxDragResult >(val2);
32642 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32643 if (!SWIG_IsOK(res3)) {
32644 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32645 }
32646 if (!argp3) {
32647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32648 }
32649 arg3 = reinterpret_cast< wxCursor * >(argp3);
32650 {
32651 PyThreadState* __tstate = wxPyBeginAllowThreads();
32652 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32653 wxPyEndAllowThreads(__tstate);
32654 if (PyErr_Occurred()) SWIG_fail;
32655 }
32656 resultobj = SWIG_Py_Void();
32657 return resultobj;
32658 fail:
32659 return NULL;
32660 }
32661
32662
32663 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32664 PyObject *resultobj = 0;
32665 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32666 int arg2 = (int) wxDrag_CopyOnly ;
32667 wxDragResult result;
32668 void *argp1 = 0 ;
32669 int res1 = 0 ;
32670 int val2 ;
32671 int ecode2 = 0 ;
32672 PyObject * obj0 = 0 ;
32673 PyObject * obj1 = 0 ;
32674 char * kwnames[] = {
32675 (char *) "self",(char *) "flags", NULL
32676 };
32677
32678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32680 if (!SWIG_IsOK(res1)) {
32681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32682 }
32683 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32684 if (obj1) {
32685 ecode2 = SWIG_AsVal_int(obj1, &val2);
32686 if (!SWIG_IsOK(ecode2)) {
32687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32688 }
32689 arg2 = static_cast< int >(val2);
32690 }
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 resultobj = SWIG_From_int(static_cast< int >(result));
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32705 PyObject *resultobj = 0;
32706 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32707 wxDragResult arg2 ;
32708 bool result;
32709 void *argp1 = 0 ;
32710 int res1 = 0 ;
32711 int val2 ;
32712 int ecode2 = 0 ;
32713 PyObject * obj0 = 0 ;
32714 PyObject * obj1 = 0 ;
32715 char * kwnames[] = {
32716 (char *) "self",(char *) "effect", NULL
32717 };
32718
32719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32721 if (!SWIG_IsOK(res1)) {
32722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32723 }
32724 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32725 ecode2 = SWIG_AsVal_int(obj1, &val2);
32726 if (!SWIG_IsOK(ecode2)) {
32727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32728 }
32729 arg2 = static_cast< wxDragResult >(val2);
32730 {
32731 PyThreadState* __tstate = wxPyBeginAllowThreads();
32732 result = (bool)(arg1)->GiveFeedback(arg2);
32733 wxPyEndAllowThreads(__tstate);
32734 if (PyErr_Occurred()) SWIG_fail;
32735 }
32736 {
32737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32738 }
32739 return resultobj;
32740 fail:
32741 return NULL;
32742 }
32743
32744
32745 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32746 PyObject *obj;
32747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32748 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32749 return SWIG_Py_Void();
32750 }
32751
32752 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32753 return SWIG_Python_InitShadowInstance(args);
32754 }
32755
32756 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32757 PyObject *resultobj = 0;
32758 wxDataObject *arg1 = (wxDataObject *) NULL ;
32759 wxPyDropTarget *result = 0 ;
32760 int res1 = 0 ;
32761 PyObject * obj0 = 0 ;
32762 char * kwnames[] = {
32763 (char *) "dataObject", NULL
32764 };
32765
32766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32767 if (obj0) {
32768 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32769 if (!SWIG_IsOK(res1)) {
32770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32771 }
32772 }
32773 {
32774 PyThreadState* __tstate = wxPyBeginAllowThreads();
32775 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32776 wxPyEndAllowThreads(__tstate);
32777 if (PyErr_Occurred()) SWIG_fail;
32778 }
32779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32780 return resultobj;
32781 fail:
32782 return NULL;
32783 }
32784
32785
32786 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32787 PyObject *resultobj = 0;
32788 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32789 PyObject *arg2 = (PyObject *) 0 ;
32790 PyObject *arg3 = (PyObject *) 0 ;
32791 void *argp1 = 0 ;
32792 int res1 = 0 ;
32793 PyObject * obj0 = 0 ;
32794 PyObject * obj1 = 0 ;
32795 PyObject * obj2 = 0 ;
32796 char * kwnames[] = {
32797 (char *) "self",(char *) "self",(char *) "_class", NULL
32798 };
32799
32800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32802 if (!SWIG_IsOK(res1)) {
32803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32804 }
32805 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32806 arg2 = obj1;
32807 arg3 = obj2;
32808 {
32809 PyThreadState* __tstate = wxPyBeginAllowThreads();
32810 (arg1)->_setCallbackInfo(arg2,arg3);
32811 wxPyEndAllowThreads(__tstate);
32812 if (PyErr_Occurred()) SWIG_fail;
32813 }
32814 resultobj = SWIG_Py_Void();
32815 return resultobj;
32816 fail:
32817 return NULL;
32818 }
32819
32820
32821 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32822 PyObject *resultobj = 0;
32823 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32824 void *argp1 = 0 ;
32825 int res1 = 0 ;
32826 PyObject *swig_obj[1] ;
32827
32828 if (!args) SWIG_fail;
32829 swig_obj[0] = args;
32830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32831 if (!SWIG_IsOK(res1)) {
32832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32833 }
32834 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32835 {
32836 PyThreadState* __tstate = wxPyBeginAllowThreads();
32837 delete arg1;
32838
32839 wxPyEndAllowThreads(__tstate);
32840 if (PyErr_Occurred()) SWIG_fail;
32841 }
32842 resultobj = SWIG_Py_Void();
32843 return resultobj;
32844 fail:
32845 return NULL;
32846 }
32847
32848
32849 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32850 PyObject *resultobj = 0;
32851 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32852 wxDataObject *result = 0 ;
32853 void *argp1 = 0 ;
32854 int res1 = 0 ;
32855 PyObject *swig_obj[1] ;
32856
32857 if (!args) SWIG_fail;
32858 swig_obj[0] = args;
32859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32860 if (!SWIG_IsOK(res1)) {
32861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32862 }
32863 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32864 {
32865 PyThreadState* __tstate = wxPyBeginAllowThreads();
32866 result = (wxDataObject *)(arg1)->GetDataObject();
32867 wxPyEndAllowThreads(__tstate);
32868 if (PyErr_Occurred()) SWIG_fail;
32869 }
32870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32871 return resultobj;
32872 fail:
32873 return NULL;
32874 }
32875
32876
32877 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32878 PyObject *resultobj = 0;
32879 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32880 wxDataObject *arg2 = (wxDataObject *) 0 ;
32881 void *argp1 = 0 ;
32882 int res1 = 0 ;
32883 int res2 = 0 ;
32884 PyObject * obj0 = 0 ;
32885 PyObject * obj1 = 0 ;
32886 char * kwnames[] = {
32887 (char *) "self",(char *) "dataObject", NULL
32888 };
32889
32890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32892 if (!SWIG_IsOK(res1)) {
32893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32894 }
32895 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32896 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32897 if (!SWIG_IsOK(res2)) {
32898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32899 }
32900 {
32901 PyThreadState* __tstate = wxPyBeginAllowThreads();
32902 (arg1)->SetDataObject(arg2);
32903 wxPyEndAllowThreads(__tstate);
32904 if (PyErr_Occurred()) SWIG_fail;
32905 }
32906 resultobj = SWIG_Py_Void();
32907 return resultobj;
32908 fail:
32909 return NULL;
32910 }
32911
32912
32913 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32914 PyObject *resultobj = 0;
32915 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32916 int arg2 ;
32917 int arg3 ;
32918 wxDragResult arg4 ;
32919 wxDragResult result;
32920 void *argp1 = 0 ;
32921 int res1 = 0 ;
32922 int val2 ;
32923 int ecode2 = 0 ;
32924 int val3 ;
32925 int ecode3 = 0 ;
32926 int val4 ;
32927 int ecode4 = 0 ;
32928 PyObject * obj0 = 0 ;
32929 PyObject * obj1 = 0 ;
32930 PyObject * obj2 = 0 ;
32931 PyObject * obj3 = 0 ;
32932 char * kwnames[] = {
32933 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32934 };
32935
32936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32938 if (!SWIG_IsOK(res1)) {
32939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32940 }
32941 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32942 ecode2 = SWIG_AsVal_int(obj1, &val2);
32943 if (!SWIG_IsOK(ecode2)) {
32944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32945 }
32946 arg2 = static_cast< int >(val2);
32947 ecode3 = SWIG_AsVal_int(obj2, &val3);
32948 if (!SWIG_IsOK(ecode3)) {
32949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32950 }
32951 arg3 = static_cast< int >(val3);
32952 ecode4 = SWIG_AsVal_int(obj3, &val4);
32953 if (!SWIG_IsOK(ecode4)) {
32954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32955 }
32956 arg4 = static_cast< wxDragResult >(val4);
32957 {
32958 PyThreadState* __tstate = wxPyBeginAllowThreads();
32959 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32960 wxPyEndAllowThreads(__tstate);
32961 if (PyErr_Occurred()) SWIG_fail;
32962 }
32963 resultobj = SWIG_From_int(static_cast< int >(result));
32964 return resultobj;
32965 fail:
32966 return NULL;
32967 }
32968
32969
32970 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32971 PyObject *resultobj = 0;
32972 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32973 int arg2 ;
32974 int arg3 ;
32975 wxDragResult arg4 ;
32976 wxDragResult result;
32977 void *argp1 = 0 ;
32978 int res1 = 0 ;
32979 int val2 ;
32980 int ecode2 = 0 ;
32981 int val3 ;
32982 int ecode3 = 0 ;
32983 int val4 ;
32984 int ecode4 = 0 ;
32985 PyObject * obj0 = 0 ;
32986 PyObject * obj1 = 0 ;
32987 PyObject * obj2 = 0 ;
32988 PyObject * obj3 = 0 ;
32989 char * kwnames[] = {
32990 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32991 };
32992
32993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32995 if (!SWIG_IsOK(res1)) {
32996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32997 }
32998 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32999 ecode2 = SWIG_AsVal_int(obj1, &val2);
33000 if (!SWIG_IsOK(ecode2)) {
33001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33002 }
33003 arg2 = static_cast< int >(val2);
33004 ecode3 = SWIG_AsVal_int(obj2, &val3);
33005 if (!SWIG_IsOK(ecode3)) {
33006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33007 }
33008 arg3 = static_cast< int >(val3);
33009 ecode4 = SWIG_AsVal_int(obj3, &val4);
33010 if (!SWIG_IsOK(ecode4)) {
33011 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33012 }
33013 arg4 = static_cast< wxDragResult >(val4);
33014 {
33015 PyThreadState* __tstate = wxPyBeginAllowThreads();
33016 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 resultobj = SWIG_From_int(static_cast< int >(result));
33021 return resultobj;
33022 fail:
33023 return NULL;
33024 }
33025
33026
33027 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33028 PyObject *resultobj = 0;
33029 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33030 void *argp1 = 0 ;
33031 int res1 = 0 ;
33032 PyObject *swig_obj[1] ;
33033
33034 if (!args) SWIG_fail;
33035 swig_obj[0] = args;
33036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33037 if (!SWIG_IsOK(res1)) {
33038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33039 }
33040 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33041 {
33042 PyThreadState* __tstate = wxPyBeginAllowThreads();
33043 (arg1)->OnLeave();
33044 wxPyEndAllowThreads(__tstate);
33045 if (PyErr_Occurred()) SWIG_fail;
33046 }
33047 resultobj = SWIG_Py_Void();
33048 return resultobj;
33049 fail:
33050 return NULL;
33051 }
33052
33053
33054 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33055 PyObject *resultobj = 0;
33056 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33057 int arg2 ;
33058 int arg3 ;
33059 bool result;
33060 void *argp1 = 0 ;
33061 int res1 = 0 ;
33062 int val2 ;
33063 int ecode2 = 0 ;
33064 int val3 ;
33065 int ecode3 = 0 ;
33066 PyObject * obj0 = 0 ;
33067 PyObject * obj1 = 0 ;
33068 PyObject * obj2 = 0 ;
33069 char * kwnames[] = {
33070 (char *) "self",(char *) "x",(char *) "y", NULL
33071 };
33072
33073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33077 }
33078 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33079 ecode2 = SWIG_AsVal_int(obj1, &val2);
33080 if (!SWIG_IsOK(ecode2)) {
33081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33082 }
33083 arg2 = static_cast< int >(val2);
33084 ecode3 = SWIG_AsVal_int(obj2, &val3);
33085 if (!SWIG_IsOK(ecode3)) {
33086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33087 }
33088 arg3 = static_cast< int >(val3);
33089 {
33090 PyThreadState* __tstate = wxPyBeginAllowThreads();
33091 result = (bool)(arg1)->OnDrop(arg2,arg3);
33092 wxPyEndAllowThreads(__tstate);
33093 if (PyErr_Occurred()) SWIG_fail;
33094 }
33095 {
33096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33097 }
33098 return resultobj;
33099 fail:
33100 return NULL;
33101 }
33102
33103
33104 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33105 PyObject *resultobj = 0;
33106 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33107 bool result;
33108 void *argp1 = 0 ;
33109 int res1 = 0 ;
33110 PyObject *swig_obj[1] ;
33111
33112 if (!args) SWIG_fail;
33113 swig_obj[0] = args;
33114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33115 if (!SWIG_IsOK(res1)) {
33116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33117 }
33118 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33119 {
33120 PyThreadState* __tstate = wxPyBeginAllowThreads();
33121 result = (bool)(arg1)->GetData();
33122 wxPyEndAllowThreads(__tstate);
33123 if (PyErr_Occurred()) SWIG_fail;
33124 }
33125 {
33126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33127 }
33128 return resultobj;
33129 fail:
33130 return NULL;
33131 }
33132
33133
33134 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33135 PyObject *resultobj = 0;
33136 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33137 wxDragResult arg2 ;
33138 void *argp1 = 0 ;
33139 int res1 = 0 ;
33140 int val2 ;
33141 int ecode2 = 0 ;
33142 PyObject * obj0 = 0 ;
33143 PyObject * obj1 = 0 ;
33144 char * kwnames[] = {
33145 (char *) "self",(char *) "action", NULL
33146 };
33147
33148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33150 if (!SWIG_IsOK(res1)) {
33151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33152 }
33153 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33154 ecode2 = SWIG_AsVal_int(obj1, &val2);
33155 if (!SWIG_IsOK(ecode2)) {
33156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33157 }
33158 arg2 = static_cast< wxDragResult >(val2);
33159 {
33160 PyThreadState* __tstate = wxPyBeginAllowThreads();
33161 (arg1)->SetDefaultAction(arg2);
33162 wxPyEndAllowThreads(__tstate);
33163 if (PyErr_Occurred()) SWIG_fail;
33164 }
33165 resultobj = SWIG_Py_Void();
33166 return resultobj;
33167 fail:
33168 return NULL;
33169 }
33170
33171
33172 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33173 PyObject *resultobj = 0;
33174 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33175 wxDragResult result;
33176 void *argp1 = 0 ;
33177 int res1 = 0 ;
33178 PyObject *swig_obj[1] ;
33179
33180 if (!args) SWIG_fail;
33181 swig_obj[0] = args;
33182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33183 if (!SWIG_IsOK(res1)) {
33184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33185 }
33186 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33187 {
33188 PyThreadState* __tstate = wxPyBeginAllowThreads();
33189 result = (wxDragResult)(arg1)->GetDefaultAction();
33190 wxPyEndAllowThreads(__tstate);
33191 if (PyErr_Occurred()) SWIG_fail;
33192 }
33193 resultobj = SWIG_From_int(static_cast< int >(result));
33194 return resultobj;
33195 fail:
33196 return NULL;
33197 }
33198
33199
33200 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33201 PyObject *obj;
33202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33203 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33204 return SWIG_Py_Void();
33205 }
33206
33207 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33208 return SWIG_Python_InitShadowInstance(args);
33209 }
33210
33211 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33212 PyObject *resultobj = 0;
33213 wxPyTextDropTarget *result = 0 ;
33214
33215 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33216 {
33217 PyThreadState* __tstate = wxPyBeginAllowThreads();
33218 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33219 wxPyEndAllowThreads(__tstate);
33220 if (PyErr_Occurred()) SWIG_fail;
33221 }
33222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33223 return resultobj;
33224 fail:
33225 return NULL;
33226 }
33227
33228
33229 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33230 PyObject *resultobj = 0;
33231 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33232 PyObject *arg2 = (PyObject *) 0 ;
33233 PyObject *arg3 = (PyObject *) 0 ;
33234 void *argp1 = 0 ;
33235 int res1 = 0 ;
33236 PyObject * obj0 = 0 ;
33237 PyObject * obj1 = 0 ;
33238 PyObject * obj2 = 0 ;
33239 char * kwnames[] = {
33240 (char *) "self",(char *) "self",(char *) "_class", NULL
33241 };
33242
33243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33245 if (!SWIG_IsOK(res1)) {
33246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33247 }
33248 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33249 arg2 = obj1;
33250 arg3 = obj2;
33251 {
33252 PyThreadState* __tstate = wxPyBeginAllowThreads();
33253 (arg1)->_setCallbackInfo(arg2,arg3);
33254 wxPyEndAllowThreads(__tstate);
33255 if (PyErr_Occurred()) SWIG_fail;
33256 }
33257 resultobj = SWIG_Py_Void();
33258 return resultobj;
33259 fail:
33260 return NULL;
33261 }
33262
33263
33264 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33265 PyObject *resultobj = 0;
33266 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33267 int arg2 ;
33268 int arg3 ;
33269 wxString *arg4 = 0 ;
33270 bool result;
33271 void *argp1 = 0 ;
33272 int res1 = 0 ;
33273 int val2 ;
33274 int ecode2 = 0 ;
33275 int val3 ;
33276 int ecode3 = 0 ;
33277 bool temp4 = false ;
33278 PyObject * obj0 = 0 ;
33279 PyObject * obj1 = 0 ;
33280 PyObject * obj2 = 0 ;
33281 PyObject * obj3 = 0 ;
33282 char * kwnames[] = {
33283 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33284 };
33285
33286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33288 if (!SWIG_IsOK(res1)) {
33289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33290 }
33291 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33292 ecode2 = SWIG_AsVal_int(obj1, &val2);
33293 if (!SWIG_IsOK(ecode2)) {
33294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33295 }
33296 arg2 = static_cast< int >(val2);
33297 ecode3 = SWIG_AsVal_int(obj2, &val3);
33298 if (!SWIG_IsOK(ecode3)) {
33299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33300 }
33301 arg3 = static_cast< int >(val3);
33302 {
33303 arg4 = wxString_in_helper(obj3);
33304 if (arg4 == NULL) SWIG_fail;
33305 temp4 = true;
33306 }
33307 {
33308 PyThreadState* __tstate = wxPyBeginAllowThreads();
33309 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33310 wxPyEndAllowThreads(__tstate);
33311 if (PyErr_Occurred()) SWIG_fail;
33312 }
33313 {
33314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33315 }
33316 {
33317 if (temp4)
33318 delete arg4;
33319 }
33320 return resultobj;
33321 fail:
33322 {
33323 if (temp4)
33324 delete arg4;
33325 }
33326 return NULL;
33327 }
33328
33329
33330 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33331 PyObject *resultobj = 0;
33332 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33333 int arg2 ;
33334 int arg3 ;
33335 wxDragResult arg4 ;
33336 wxDragResult result;
33337 void *argp1 = 0 ;
33338 int res1 = 0 ;
33339 int val2 ;
33340 int ecode2 = 0 ;
33341 int val3 ;
33342 int ecode3 = 0 ;
33343 int val4 ;
33344 int ecode4 = 0 ;
33345 PyObject * obj0 = 0 ;
33346 PyObject * obj1 = 0 ;
33347 PyObject * obj2 = 0 ;
33348 PyObject * obj3 = 0 ;
33349 char * kwnames[] = {
33350 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33351 };
33352
33353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33355 if (!SWIG_IsOK(res1)) {
33356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33357 }
33358 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33359 ecode2 = SWIG_AsVal_int(obj1, &val2);
33360 if (!SWIG_IsOK(ecode2)) {
33361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33362 }
33363 arg2 = static_cast< int >(val2);
33364 ecode3 = SWIG_AsVal_int(obj2, &val3);
33365 if (!SWIG_IsOK(ecode3)) {
33366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33367 }
33368 arg3 = static_cast< int >(val3);
33369 ecode4 = SWIG_AsVal_int(obj3, &val4);
33370 if (!SWIG_IsOK(ecode4)) {
33371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33372 }
33373 arg4 = static_cast< wxDragResult >(val4);
33374 {
33375 PyThreadState* __tstate = wxPyBeginAllowThreads();
33376 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33377 wxPyEndAllowThreads(__tstate);
33378 if (PyErr_Occurred()) SWIG_fail;
33379 }
33380 resultobj = SWIG_From_int(static_cast< int >(result));
33381 return resultobj;
33382 fail:
33383 return NULL;
33384 }
33385
33386
33387 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33388 PyObject *resultobj = 0;
33389 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33390 int arg2 ;
33391 int arg3 ;
33392 wxDragResult arg4 ;
33393 wxDragResult result;
33394 void *argp1 = 0 ;
33395 int res1 = 0 ;
33396 int val2 ;
33397 int ecode2 = 0 ;
33398 int val3 ;
33399 int ecode3 = 0 ;
33400 int val4 ;
33401 int ecode4 = 0 ;
33402 PyObject * obj0 = 0 ;
33403 PyObject * obj1 = 0 ;
33404 PyObject * obj2 = 0 ;
33405 PyObject * obj3 = 0 ;
33406 char * kwnames[] = {
33407 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33408 };
33409
33410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33412 if (!SWIG_IsOK(res1)) {
33413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33414 }
33415 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33416 ecode2 = SWIG_AsVal_int(obj1, &val2);
33417 if (!SWIG_IsOK(ecode2)) {
33418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33419 }
33420 arg2 = static_cast< int >(val2);
33421 ecode3 = SWIG_AsVal_int(obj2, &val3);
33422 if (!SWIG_IsOK(ecode3)) {
33423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33424 }
33425 arg3 = static_cast< int >(val3);
33426 ecode4 = SWIG_AsVal_int(obj3, &val4);
33427 if (!SWIG_IsOK(ecode4)) {
33428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33429 }
33430 arg4 = static_cast< wxDragResult >(val4);
33431 {
33432 PyThreadState* __tstate = wxPyBeginAllowThreads();
33433 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33434 wxPyEndAllowThreads(__tstate);
33435 if (PyErr_Occurred()) SWIG_fail;
33436 }
33437 resultobj = SWIG_From_int(static_cast< int >(result));
33438 return resultobj;
33439 fail:
33440 return NULL;
33441 }
33442
33443
33444 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33445 PyObject *resultobj = 0;
33446 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33447 void *argp1 = 0 ;
33448 int res1 = 0 ;
33449 PyObject *swig_obj[1] ;
33450
33451 if (!args) SWIG_fail;
33452 swig_obj[0] = args;
33453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33454 if (!SWIG_IsOK(res1)) {
33455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33456 }
33457 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33458 {
33459 PyThreadState* __tstate = wxPyBeginAllowThreads();
33460 (arg1)->OnLeave();
33461 wxPyEndAllowThreads(__tstate);
33462 if (PyErr_Occurred()) SWIG_fail;
33463 }
33464 resultobj = SWIG_Py_Void();
33465 return resultobj;
33466 fail:
33467 return NULL;
33468 }
33469
33470
33471 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33472 PyObject *resultobj = 0;
33473 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33474 int arg2 ;
33475 int arg3 ;
33476 bool result;
33477 void *argp1 = 0 ;
33478 int res1 = 0 ;
33479 int val2 ;
33480 int ecode2 = 0 ;
33481 int val3 ;
33482 int ecode3 = 0 ;
33483 PyObject * obj0 = 0 ;
33484 PyObject * obj1 = 0 ;
33485 PyObject * obj2 = 0 ;
33486 char * kwnames[] = {
33487 (char *) "self",(char *) "x",(char *) "y", NULL
33488 };
33489
33490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33492 if (!SWIG_IsOK(res1)) {
33493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33494 }
33495 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33496 ecode2 = SWIG_AsVal_int(obj1, &val2);
33497 if (!SWIG_IsOK(ecode2)) {
33498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33499 }
33500 arg2 = static_cast< int >(val2);
33501 ecode3 = SWIG_AsVal_int(obj2, &val3);
33502 if (!SWIG_IsOK(ecode3)) {
33503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33504 }
33505 arg3 = static_cast< int >(val3);
33506 {
33507 PyThreadState* __tstate = wxPyBeginAllowThreads();
33508 result = (bool)(arg1)->OnDrop(arg2,arg3);
33509 wxPyEndAllowThreads(__tstate);
33510 if (PyErr_Occurred()) SWIG_fail;
33511 }
33512 {
33513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33514 }
33515 return resultobj;
33516 fail:
33517 return NULL;
33518 }
33519
33520
33521 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33522 PyObject *resultobj = 0;
33523 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33524 int arg2 ;
33525 int arg3 ;
33526 wxDragResult arg4 ;
33527 wxDragResult result;
33528 void *argp1 = 0 ;
33529 int res1 = 0 ;
33530 int val2 ;
33531 int ecode2 = 0 ;
33532 int val3 ;
33533 int ecode3 = 0 ;
33534 int val4 ;
33535 int ecode4 = 0 ;
33536 PyObject * obj0 = 0 ;
33537 PyObject * obj1 = 0 ;
33538 PyObject * obj2 = 0 ;
33539 PyObject * obj3 = 0 ;
33540 char * kwnames[] = {
33541 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33542 };
33543
33544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33546 if (!SWIG_IsOK(res1)) {
33547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33548 }
33549 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33550 ecode2 = SWIG_AsVal_int(obj1, &val2);
33551 if (!SWIG_IsOK(ecode2)) {
33552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33553 }
33554 arg2 = static_cast< int >(val2);
33555 ecode3 = SWIG_AsVal_int(obj2, &val3);
33556 if (!SWIG_IsOK(ecode3)) {
33557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33558 }
33559 arg3 = static_cast< int >(val3);
33560 ecode4 = SWIG_AsVal_int(obj3, &val4);
33561 if (!SWIG_IsOK(ecode4)) {
33562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33563 }
33564 arg4 = static_cast< wxDragResult >(val4);
33565 {
33566 PyThreadState* __tstate = wxPyBeginAllowThreads();
33567 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33568 wxPyEndAllowThreads(__tstate);
33569 if (PyErr_Occurred()) SWIG_fail;
33570 }
33571 resultobj = SWIG_From_int(static_cast< int >(result));
33572 return resultobj;
33573 fail:
33574 return NULL;
33575 }
33576
33577
33578 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33579 PyObject *obj;
33580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33581 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33582 return SWIG_Py_Void();
33583 }
33584
33585 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33586 return SWIG_Python_InitShadowInstance(args);
33587 }
33588
33589 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33590 PyObject *resultobj = 0;
33591 wxPyFileDropTarget *result = 0 ;
33592
33593 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33594 {
33595 PyThreadState* __tstate = wxPyBeginAllowThreads();
33596 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33597 wxPyEndAllowThreads(__tstate);
33598 if (PyErr_Occurred()) SWIG_fail;
33599 }
33600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33601 return resultobj;
33602 fail:
33603 return NULL;
33604 }
33605
33606
33607 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33608 PyObject *resultobj = 0;
33609 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33610 PyObject *arg2 = (PyObject *) 0 ;
33611 PyObject *arg3 = (PyObject *) 0 ;
33612 void *argp1 = 0 ;
33613 int res1 = 0 ;
33614 PyObject * obj0 = 0 ;
33615 PyObject * obj1 = 0 ;
33616 PyObject * obj2 = 0 ;
33617 char * kwnames[] = {
33618 (char *) "self",(char *) "self",(char *) "_class", NULL
33619 };
33620
33621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33623 if (!SWIG_IsOK(res1)) {
33624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33625 }
33626 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33627 arg2 = obj1;
33628 arg3 = obj2;
33629 {
33630 PyThreadState* __tstate = wxPyBeginAllowThreads();
33631 (arg1)->_setCallbackInfo(arg2,arg3);
33632 wxPyEndAllowThreads(__tstate);
33633 if (PyErr_Occurred()) SWIG_fail;
33634 }
33635 resultobj = SWIG_Py_Void();
33636 return resultobj;
33637 fail:
33638 return NULL;
33639 }
33640
33641
33642 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33643 PyObject *resultobj = 0;
33644 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33645 int arg2 ;
33646 int arg3 ;
33647 wxArrayString *arg4 = 0 ;
33648 bool result;
33649 void *argp1 = 0 ;
33650 int res1 = 0 ;
33651 int val2 ;
33652 int ecode2 = 0 ;
33653 int val3 ;
33654 int ecode3 = 0 ;
33655 bool temp4 = false ;
33656 PyObject * obj0 = 0 ;
33657 PyObject * obj1 = 0 ;
33658 PyObject * obj2 = 0 ;
33659 PyObject * obj3 = 0 ;
33660 char * kwnames[] = {
33661 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33662 };
33663
33664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33666 if (!SWIG_IsOK(res1)) {
33667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33668 }
33669 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33670 ecode2 = SWIG_AsVal_int(obj1, &val2);
33671 if (!SWIG_IsOK(ecode2)) {
33672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33673 }
33674 arg2 = static_cast< int >(val2);
33675 ecode3 = SWIG_AsVal_int(obj2, &val3);
33676 if (!SWIG_IsOK(ecode3)) {
33677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33678 }
33679 arg3 = static_cast< int >(val3);
33680 {
33681 if (! PySequence_Check(obj3)) {
33682 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33683 SWIG_fail;
33684 }
33685 arg4 = new wxArrayString;
33686 temp4 = true;
33687 int i, len=PySequence_Length(obj3);
33688 for (i=0; i<len; i++) {
33689 PyObject* item = PySequence_GetItem(obj3, i);
33690 wxString* s = wxString_in_helper(item);
33691 if (PyErr_Occurred()) SWIG_fail;
33692 arg4->Add(*s);
33693 delete s;
33694 Py_DECREF(item);
33695 }
33696 }
33697 {
33698 PyThreadState* __tstate = wxPyBeginAllowThreads();
33699 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33700 wxPyEndAllowThreads(__tstate);
33701 if (PyErr_Occurred()) SWIG_fail;
33702 }
33703 {
33704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33705 }
33706 {
33707 if (temp4) delete arg4;
33708 }
33709 return resultobj;
33710 fail:
33711 {
33712 if (temp4) delete arg4;
33713 }
33714 return NULL;
33715 }
33716
33717
33718 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33719 PyObject *resultobj = 0;
33720 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33721 int arg2 ;
33722 int arg3 ;
33723 wxDragResult arg4 ;
33724 wxDragResult result;
33725 void *argp1 = 0 ;
33726 int res1 = 0 ;
33727 int val2 ;
33728 int ecode2 = 0 ;
33729 int val3 ;
33730 int ecode3 = 0 ;
33731 int val4 ;
33732 int ecode4 = 0 ;
33733 PyObject * obj0 = 0 ;
33734 PyObject * obj1 = 0 ;
33735 PyObject * obj2 = 0 ;
33736 PyObject * obj3 = 0 ;
33737 char * kwnames[] = {
33738 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33739 };
33740
33741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33743 if (!SWIG_IsOK(res1)) {
33744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33745 }
33746 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33747 ecode2 = SWIG_AsVal_int(obj1, &val2);
33748 if (!SWIG_IsOK(ecode2)) {
33749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33750 }
33751 arg2 = static_cast< int >(val2);
33752 ecode3 = SWIG_AsVal_int(obj2, &val3);
33753 if (!SWIG_IsOK(ecode3)) {
33754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33755 }
33756 arg3 = static_cast< int >(val3);
33757 ecode4 = SWIG_AsVal_int(obj3, &val4);
33758 if (!SWIG_IsOK(ecode4)) {
33759 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33760 }
33761 arg4 = static_cast< wxDragResult >(val4);
33762 {
33763 PyThreadState* __tstate = wxPyBeginAllowThreads();
33764 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33765 wxPyEndAllowThreads(__tstate);
33766 if (PyErr_Occurred()) SWIG_fail;
33767 }
33768 resultobj = SWIG_From_int(static_cast< int >(result));
33769 return resultobj;
33770 fail:
33771 return NULL;
33772 }
33773
33774
33775 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33776 PyObject *resultobj = 0;
33777 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33778 int arg2 ;
33779 int arg3 ;
33780 wxDragResult arg4 ;
33781 wxDragResult result;
33782 void *argp1 = 0 ;
33783 int res1 = 0 ;
33784 int val2 ;
33785 int ecode2 = 0 ;
33786 int val3 ;
33787 int ecode3 = 0 ;
33788 int val4 ;
33789 int ecode4 = 0 ;
33790 PyObject * obj0 = 0 ;
33791 PyObject * obj1 = 0 ;
33792 PyObject * obj2 = 0 ;
33793 PyObject * obj3 = 0 ;
33794 char * kwnames[] = {
33795 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33796 };
33797
33798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33802 }
33803 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33804 ecode2 = SWIG_AsVal_int(obj1, &val2);
33805 if (!SWIG_IsOK(ecode2)) {
33806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33807 }
33808 arg2 = static_cast< int >(val2);
33809 ecode3 = SWIG_AsVal_int(obj2, &val3);
33810 if (!SWIG_IsOK(ecode3)) {
33811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33812 }
33813 arg3 = static_cast< int >(val3);
33814 ecode4 = SWIG_AsVal_int(obj3, &val4);
33815 if (!SWIG_IsOK(ecode4)) {
33816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33817 }
33818 arg4 = static_cast< wxDragResult >(val4);
33819 {
33820 PyThreadState* __tstate = wxPyBeginAllowThreads();
33821 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33822 wxPyEndAllowThreads(__tstate);
33823 if (PyErr_Occurred()) SWIG_fail;
33824 }
33825 resultobj = SWIG_From_int(static_cast< int >(result));
33826 return resultobj;
33827 fail:
33828 return NULL;
33829 }
33830
33831
33832 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33833 PyObject *resultobj = 0;
33834 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33835 void *argp1 = 0 ;
33836 int res1 = 0 ;
33837 PyObject *swig_obj[1] ;
33838
33839 if (!args) SWIG_fail;
33840 swig_obj[0] = args;
33841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33842 if (!SWIG_IsOK(res1)) {
33843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33844 }
33845 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 (arg1)->OnLeave();
33849 wxPyEndAllowThreads(__tstate);
33850 if (PyErr_Occurred()) SWIG_fail;
33851 }
33852 resultobj = SWIG_Py_Void();
33853 return resultobj;
33854 fail:
33855 return NULL;
33856 }
33857
33858
33859 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33860 PyObject *resultobj = 0;
33861 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33862 int arg2 ;
33863 int arg3 ;
33864 bool result;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 int val2 ;
33868 int ecode2 = 0 ;
33869 int val3 ;
33870 int ecode3 = 0 ;
33871 PyObject * obj0 = 0 ;
33872 PyObject * obj1 = 0 ;
33873 PyObject * obj2 = 0 ;
33874 char * kwnames[] = {
33875 (char *) "self",(char *) "x",(char *) "y", NULL
33876 };
33877
33878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33880 if (!SWIG_IsOK(res1)) {
33881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33882 }
33883 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33884 ecode2 = SWIG_AsVal_int(obj1, &val2);
33885 if (!SWIG_IsOK(ecode2)) {
33886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33887 }
33888 arg2 = static_cast< int >(val2);
33889 ecode3 = SWIG_AsVal_int(obj2, &val3);
33890 if (!SWIG_IsOK(ecode3)) {
33891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33892 }
33893 arg3 = static_cast< int >(val3);
33894 {
33895 PyThreadState* __tstate = wxPyBeginAllowThreads();
33896 result = (bool)(arg1)->OnDrop(arg2,arg3);
33897 wxPyEndAllowThreads(__tstate);
33898 if (PyErr_Occurred()) SWIG_fail;
33899 }
33900 {
33901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33902 }
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33910 PyObject *resultobj = 0;
33911 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33912 int arg2 ;
33913 int arg3 ;
33914 wxDragResult arg4 ;
33915 wxDragResult result;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 int val2 ;
33919 int ecode2 = 0 ;
33920 int val3 ;
33921 int ecode3 = 0 ;
33922 int val4 ;
33923 int ecode4 = 0 ;
33924 PyObject * obj0 = 0 ;
33925 PyObject * obj1 = 0 ;
33926 PyObject * obj2 = 0 ;
33927 PyObject * obj3 = 0 ;
33928 char * kwnames[] = {
33929 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33930 };
33931
33932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33934 if (!SWIG_IsOK(res1)) {
33935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33936 }
33937 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33938 ecode2 = SWIG_AsVal_int(obj1, &val2);
33939 if (!SWIG_IsOK(ecode2)) {
33940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33941 }
33942 arg2 = static_cast< int >(val2);
33943 ecode3 = SWIG_AsVal_int(obj2, &val3);
33944 if (!SWIG_IsOK(ecode3)) {
33945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33946 }
33947 arg3 = static_cast< int >(val3);
33948 ecode4 = SWIG_AsVal_int(obj3, &val4);
33949 if (!SWIG_IsOK(ecode4)) {
33950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33951 }
33952 arg4 = static_cast< wxDragResult >(val4);
33953 {
33954 PyThreadState* __tstate = wxPyBeginAllowThreads();
33955 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 resultobj = SWIG_From_int(static_cast< int >(result));
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33967 PyObject *obj;
33968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33969 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33970 return SWIG_Py_Void();
33971 }
33972
33973 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33974 return SWIG_Python_InitShadowInstance(args);
33975 }
33976
33977 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33978 PyObject *resultobj = 0;
33979 wxClipboard *result = 0 ;
33980
33981 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33982 {
33983 PyThreadState* __tstate = wxPyBeginAllowThreads();
33984 result = (wxClipboard *)new wxClipboard();
33985 wxPyEndAllowThreads(__tstate);
33986 if (PyErr_Occurred()) SWIG_fail;
33987 }
33988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33989 return resultobj;
33990 fail:
33991 return NULL;
33992 }
33993
33994
33995 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33996 PyObject *resultobj = 0;
33997 wxClipboard *arg1 = (wxClipboard *) 0 ;
33998 void *argp1 = 0 ;
33999 int res1 = 0 ;
34000 PyObject *swig_obj[1] ;
34001
34002 if (!args) SWIG_fail;
34003 swig_obj[0] = args;
34004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34005 if (!SWIG_IsOK(res1)) {
34006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34007 }
34008 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34009 {
34010 PyThreadState* __tstate = wxPyBeginAllowThreads();
34011 delete arg1;
34012
34013 wxPyEndAllowThreads(__tstate);
34014 if (PyErr_Occurred()) SWIG_fail;
34015 }
34016 resultobj = SWIG_Py_Void();
34017 return resultobj;
34018 fail:
34019 return NULL;
34020 }
34021
34022
34023 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34024 PyObject *resultobj = 0;
34025 wxClipboard *arg1 = (wxClipboard *) 0 ;
34026 bool result;
34027 void *argp1 = 0 ;
34028 int res1 = 0 ;
34029 PyObject *swig_obj[1] ;
34030
34031 if (!args) SWIG_fail;
34032 swig_obj[0] = args;
34033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34034 if (!SWIG_IsOK(res1)) {
34035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34036 }
34037 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34038 {
34039 PyThreadState* __tstate = wxPyBeginAllowThreads();
34040 result = (bool)(arg1)->Open();
34041 wxPyEndAllowThreads(__tstate);
34042 if (PyErr_Occurred()) SWIG_fail;
34043 }
34044 {
34045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34046 }
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34054 PyObject *resultobj = 0;
34055 wxClipboard *arg1 = (wxClipboard *) 0 ;
34056 void *argp1 = 0 ;
34057 int res1 = 0 ;
34058 PyObject *swig_obj[1] ;
34059
34060 if (!args) SWIG_fail;
34061 swig_obj[0] = args;
34062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34065 }
34066 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34067 {
34068 PyThreadState* __tstate = wxPyBeginAllowThreads();
34069 (arg1)->Close();
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 resultobj = SWIG_Py_Void();
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34081 PyObject *resultobj = 0;
34082 wxClipboard *arg1 = (wxClipboard *) 0 ;
34083 bool result;
34084 void *argp1 = 0 ;
34085 int res1 = 0 ;
34086 PyObject *swig_obj[1] ;
34087
34088 if (!args) SWIG_fail;
34089 swig_obj[0] = args;
34090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34091 if (!SWIG_IsOK(res1)) {
34092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34093 }
34094 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
34097 result = (bool)((wxClipboard const *)arg1)->IsOpened();
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_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34111 PyObject *resultobj = 0;
34112 wxClipboard *arg1 = (wxClipboard *) 0 ;
34113 wxDataObject *arg2 = (wxDataObject *) 0 ;
34114 bool result;
34115 void *argp1 = 0 ;
34116 int res1 = 0 ;
34117 int res2 = 0 ;
34118 PyObject * obj0 = 0 ;
34119 PyObject * obj1 = 0 ;
34120 char * kwnames[] = {
34121 (char *) "self",(char *) "data", NULL
34122 };
34123
34124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34126 if (!SWIG_IsOK(res1)) {
34127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34128 }
34129 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34130 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34131 if (!SWIG_IsOK(res2)) {
34132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34133 }
34134 {
34135 PyThreadState* __tstate = wxPyBeginAllowThreads();
34136 result = (bool)(arg1)->AddData(arg2);
34137 wxPyEndAllowThreads(__tstate);
34138 if (PyErr_Occurred()) SWIG_fail;
34139 }
34140 {
34141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34142 }
34143 return resultobj;
34144 fail:
34145 return NULL;
34146 }
34147
34148
34149 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34150 PyObject *resultobj = 0;
34151 wxClipboard *arg1 = (wxClipboard *) 0 ;
34152 wxDataObject *arg2 = (wxDataObject *) 0 ;
34153 bool result;
34154 void *argp1 = 0 ;
34155 int res1 = 0 ;
34156 int res2 = 0 ;
34157 PyObject * obj0 = 0 ;
34158 PyObject * obj1 = 0 ;
34159 char * kwnames[] = {
34160 (char *) "self",(char *) "data", NULL
34161 };
34162
34163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34165 if (!SWIG_IsOK(res1)) {
34166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34167 }
34168 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34169 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34170 if (!SWIG_IsOK(res2)) {
34171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34172 }
34173 {
34174 PyThreadState* __tstate = wxPyBeginAllowThreads();
34175 result = (bool)(arg1)->SetData(arg2);
34176 wxPyEndAllowThreads(__tstate);
34177 if (PyErr_Occurred()) SWIG_fail;
34178 }
34179 {
34180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34181 }
34182 return resultobj;
34183 fail:
34184 return NULL;
34185 }
34186
34187
34188 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34189 PyObject *resultobj = 0;
34190 wxClipboard *arg1 = (wxClipboard *) 0 ;
34191 wxDataFormat *arg2 = 0 ;
34192 bool result;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 void *argp2 = 0 ;
34196 int res2 = 0 ;
34197 PyObject * obj0 = 0 ;
34198 PyObject * obj1 = 0 ;
34199 char * kwnames[] = {
34200 (char *) "self",(char *) "format", NULL
34201 };
34202
34203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34205 if (!SWIG_IsOK(res1)) {
34206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34207 }
34208 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34209 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34210 if (!SWIG_IsOK(res2)) {
34211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34212 }
34213 if (!argp2) {
34214 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34215 }
34216 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34217 {
34218 PyThreadState* __tstate = wxPyBeginAllowThreads();
34219 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34220 wxPyEndAllowThreads(__tstate);
34221 if (PyErr_Occurred()) SWIG_fail;
34222 }
34223 {
34224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34225 }
34226 return resultobj;
34227 fail:
34228 return NULL;
34229 }
34230
34231
34232 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34233 PyObject *resultobj = 0;
34234 wxClipboard *arg1 = (wxClipboard *) 0 ;
34235 wxDataObject *arg2 = 0 ;
34236 bool result;
34237 void *argp1 = 0 ;
34238 int res1 = 0 ;
34239 void *argp2 = 0 ;
34240 int res2 = 0 ;
34241 PyObject * obj0 = 0 ;
34242 PyObject * obj1 = 0 ;
34243 char * kwnames[] = {
34244 (char *) "self",(char *) "data", NULL
34245 };
34246
34247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34251 }
34252 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34254 if (!SWIG_IsOK(res2)) {
34255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34256 }
34257 if (!argp2) {
34258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34259 }
34260 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34261 {
34262 PyThreadState* __tstate = wxPyBeginAllowThreads();
34263 result = (bool)(arg1)->GetData(*arg2);
34264 wxPyEndAllowThreads(__tstate);
34265 if (PyErr_Occurred()) SWIG_fail;
34266 }
34267 {
34268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34269 }
34270 return resultobj;
34271 fail:
34272 return NULL;
34273 }
34274
34275
34276 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34277 PyObject *resultobj = 0;
34278 wxClipboard *arg1 = (wxClipboard *) 0 ;
34279 void *argp1 = 0 ;
34280 int res1 = 0 ;
34281 PyObject *swig_obj[1] ;
34282
34283 if (!args) SWIG_fail;
34284 swig_obj[0] = args;
34285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34286 if (!SWIG_IsOK(res1)) {
34287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34288 }
34289 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34290 {
34291 PyThreadState* __tstate = wxPyBeginAllowThreads();
34292 (arg1)->Clear();
34293 wxPyEndAllowThreads(__tstate);
34294 if (PyErr_Occurred()) SWIG_fail;
34295 }
34296 resultobj = SWIG_Py_Void();
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34304 PyObject *resultobj = 0;
34305 wxClipboard *arg1 = (wxClipboard *) 0 ;
34306 bool result;
34307 void *argp1 = 0 ;
34308 int res1 = 0 ;
34309 PyObject *swig_obj[1] ;
34310
34311 if (!args) SWIG_fail;
34312 swig_obj[0] = args;
34313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34314 if (!SWIG_IsOK(res1)) {
34315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34316 }
34317 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34318 {
34319 PyThreadState* __tstate = wxPyBeginAllowThreads();
34320 result = (bool)(arg1)->Flush();
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 {
34325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34326 }
34327 return resultobj;
34328 fail:
34329 return NULL;
34330 }
34331
34332
34333 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34334 PyObject *resultobj = 0;
34335 wxClipboard *arg1 = (wxClipboard *) 0 ;
34336 bool arg2 = (bool) true ;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 bool val2 ;
34340 int ecode2 = 0 ;
34341 PyObject * obj0 = 0 ;
34342 PyObject * obj1 = 0 ;
34343 char * kwnames[] = {
34344 (char *) "self",(char *) "primary", NULL
34345 };
34346
34347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34349 if (!SWIG_IsOK(res1)) {
34350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34351 }
34352 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34353 if (obj1) {
34354 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34355 if (!SWIG_IsOK(ecode2)) {
34356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34357 }
34358 arg2 = static_cast< bool >(val2);
34359 }
34360 {
34361 PyThreadState* __tstate = wxPyBeginAllowThreads();
34362 (arg1)->UsePrimarySelection(arg2);
34363 wxPyEndAllowThreads(__tstate);
34364 if (PyErr_Occurred()) SWIG_fail;
34365 }
34366 resultobj = SWIG_Py_Void();
34367 return resultobj;
34368 fail:
34369 return NULL;
34370 }
34371
34372
34373 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34374 PyObject *resultobj = 0;
34375 wxClipboard *result = 0 ;
34376
34377 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34378 {
34379 PyThreadState* __tstate = wxPyBeginAllowThreads();
34380 result = (wxClipboard *)wxClipboard::Get();
34381 wxPyEndAllowThreads(__tstate);
34382 if (PyErr_Occurred()) SWIG_fail;
34383 }
34384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34385 return resultobj;
34386 fail:
34387 return NULL;
34388 }
34389
34390
34391 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34392 PyObject *obj;
34393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34394 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34395 return SWIG_Py_Void();
34396 }
34397
34398 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34399 return SWIG_Python_InitShadowInstance(args);
34400 }
34401
34402 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj = 0;
34404 wxClipboard *arg1 = (wxClipboard *) NULL ;
34405 wxClipboardLocker *result = 0 ;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 PyObject * obj0 = 0 ;
34409 char * kwnames[] = {
34410 (char *) "clipboard", NULL
34411 };
34412
34413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34414 if (obj0) {
34415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34416 if (!SWIG_IsOK(res1)) {
34417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34418 }
34419 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34420 }
34421 {
34422 PyThreadState* __tstate = wxPyBeginAllowThreads();
34423 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34424 wxPyEndAllowThreads(__tstate);
34425 if (PyErr_Occurred()) SWIG_fail;
34426 }
34427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34428 return resultobj;
34429 fail:
34430 return NULL;
34431 }
34432
34433
34434 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34435 PyObject *resultobj = 0;
34436 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34437 void *argp1 = 0 ;
34438 int res1 = 0 ;
34439 PyObject *swig_obj[1] ;
34440
34441 if (!args) SWIG_fail;
34442 swig_obj[0] = args;
34443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34444 if (!SWIG_IsOK(res1)) {
34445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34446 }
34447 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34448 {
34449 PyThreadState* __tstate = wxPyBeginAllowThreads();
34450 delete arg1;
34451
34452 wxPyEndAllowThreads(__tstate);
34453 if (PyErr_Occurred()) SWIG_fail;
34454 }
34455 resultobj = SWIG_Py_Void();
34456 return resultobj;
34457 fail:
34458 return NULL;
34459 }
34460
34461
34462 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34463 PyObject *resultobj = 0;
34464 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34465 bool result;
34466 void *argp1 = 0 ;
34467 int res1 = 0 ;
34468 PyObject *swig_obj[1] ;
34469
34470 if (!args) SWIG_fail;
34471 swig_obj[0] = args;
34472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34473 if (!SWIG_IsOK(res1)) {
34474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34475 }
34476 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34477 {
34478 PyThreadState* __tstate = wxPyBeginAllowThreads();
34479 result = (bool)wxClipboardLocker___nonzero__(arg1);
34480 wxPyEndAllowThreads(__tstate);
34481 if (PyErr_Occurred()) SWIG_fail;
34482 }
34483 {
34484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34485 }
34486 return resultobj;
34487 fail:
34488 return NULL;
34489 }
34490
34491
34492 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34493 PyObject *obj;
34494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34495 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34496 return SWIG_Py_Void();
34497 }
34498
34499 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34500 return SWIG_Python_InitShadowInstance(args);
34501 }
34502
34503 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34504 PyObject *resultobj = 0;
34505 int arg1 = (int) 0 ;
34506 int arg2 = (int) 0 ;
34507 int arg3 = (int) 0 ;
34508 int arg4 = (int) 0 ;
34509 wxVideoMode *result = 0 ;
34510 int val1 ;
34511 int ecode1 = 0 ;
34512 int val2 ;
34513 int ecode2 = 0 ;
34514 int val3 ;
34515 int ecode3 = 0 ;
34516 int val4 ;
34517 int ecode4 = 0 ;
34518 PyObject * obj0 = 0 ;
34519 PyObject * obj1 = 0 ;
34520 PyObject * obj2 = 0 ;
34521 PyObject * obj3 = 0 ;
34522 char * kwnames[] = {
34523 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34524 };
34525
34526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34527 if (obj0) {
34528 ecode1 = SWIG_AsVal_int(obj0, &val1);
34529 if (!SWIG_IsOK(ecode1)) {
34530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34531 }
34532 arg1 = static_cast< int >(val1);
34533 }
34534 if (obj1) {
34535 ecode2 = SWIG_AsVal_int(obj1, &val2);
34536 if (!SWIG_IsOK(ecode2)) {
34537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34538 }
34539 arg2 = static_cast< int >(val2);
34540 }
34541 if (obj2) {
34542 ecode3 = SWIG_AsVal_int(obj2, &val3);
34543 if (!SWIG_IsOK(ecode3)) {
34544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34545 }
34546 arg3 = static_cast< int >(val3);
34547 }
34548 if (obj3) {
34549 ecode4 = SWIG_AsVal_int(obj3, &val4);
34550 if (!SWIG_IsOK(ecode4)) {
34551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34552 }
34553 arg4 = static_cast< int >(val4);
34554 }
34555 {
34556 PyThreadState* __tstate = wxPyBeginAllowThreads();
34557 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34562 return resultobj;
34563 fail:
34564 return NULL;
34565 }
34566
34567
34568 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34569 PyObject *resultobj = 0;
34570 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34571 void *argp1 = 0 ;
34572 int res1 = 0 ;
34573 PyObject *swig_obj[1] ;
34574
34575 if (!args) SWIG_fail;
34576 swig_obj[0] = args;
34577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34578 if (!SWIG_IsOK(res1)) {
34579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34580 }
34581 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34582 {
34583 PyThreadState* __tstate = wxPyBeginAllowThreads();
34584 delete arg1;
34585
34586 wxPyEndAllowThreads(__tstate);
34587 if (PyErr_Occurred()) SWIG_fail;
34588 }
34589 resultobj = SWIG_Py_Void();
34590 return resultobj;
34591 fail:
34592 return NULL;
34593 }
34594
34595
34596 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34597 PyObject *resultobj = 0;
34598 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34599 wxVideoMode *arg2 = 0 ;
34600 bool result;
34601 void *argp1 = 0 ;
34602 int res1 = 0 ;
34603 void *argp2 = 0 ;
34604 int res2 = 0 ;
34605 PyObject * obj0 = 0 ;
34606 PyObject * obj1 = 0 ;
34607 char * kwnames[] = {
34608 (char *) "self",(char *) "other", NULL
34609 };
34610
34611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34615 }
34616 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34617 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34618 if (!SWIG_IsOK(res2)) {
34619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34620 }
34621 if (!argp2) {
34622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34623 }
34624 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 {
34632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34633 }
34634 return resultobj;
34635 fail:
34636 return NULL;
34637 }
34638
34639
34640 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34641 PyObject *resultobj = 0;
34642 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34643 int result;
34644 void *argp1 = 0 ;
34645 int res1 = 0 ;
34646 PyObject *swig_obj[1] ;
34647
34648 if (!args) SWIG_fail;
34649 swig_obj[0] = args;
34650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34651 if (!SWIG_IsOK(res1)) {
34652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34653 }
34654 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34655 {
34656 PyThreadState* __tstate = wxPyBeginAllowThreads();
34657 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34658 wxPyEndAllowThreads(__tstate);
34659 if (PyErr_Occurred()) SWIG_fail;
34660 }
34661 resultobj = SWIG_From_int(static_cast< int >(result));
34662 return resultobj;
34663 fail:
34664 return NULL;
34665 }
34666
34667
34668 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34669 PyObject *resultobj = 0;
34670 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34671 int result;
34672 void *argp1 = 0 ;
34673 int res1 = 0 ;
34674 PyObject *swig_obj[1] ;
34675
34676 if (!args) SWIG_fail;
34677 swig_obj[0] = args;
34678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34679 if (!SWIG_IsOK(res1)) {
34680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34681 }
34682 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34683 {
34684 PyThreadState* __tstate = wxPyBeginAllowThreads();
34685 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34686 wxPyEndAllowThreads(__tstate);
34687 if (PyErr_Occurred()) SWIG_fail;
34688 }
34689 resultobj = SWIG_From_int(static_cast< int >(result));
34690 return resultobj;
34691 fail:
34692 return NULL;
34693 }
34694
34695
34696 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34697 PyObject *resultobj = 0;
34698 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34699 int result;
34700 void *argp1 = 0 ;
34701 int res1 = 0 ;
34702 PyObject *swig_obj[1] ;
34703
34704 if (!args) SWIG_fail;
34705 swig_obj[0] = args;
34706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34707 if (!SWIG_IsOK(res1)) {
34708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34709 }
34710 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34711 {
34712 PyThreadState* __tstate = wxPyBeginAllowThreads();
34713 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34714 wxPyEndAllowThreads(__tstate);
34715 if (PyErr_Occurred()) SWIG_fail;
34716 }
34717 resultobj = SWIG_From_int(static_cast< int >(result));
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34725 PyObject *resultobj = 0;
34726 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34727 bool result;
34728 void *argp1 = 0 ;
34729 int res1 = 0 ;
34730 PyObject *swig_obj[1] ;
34731
34732 if (!args) SWIG_fail;
34733 swig_obj[0] = args;
34734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34735 if (!SWIG_IsOK(res1)) {
34736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34737 }
34738 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34739 {
34740 PyThreadState* __tstate = wxPyBeginAllowThreads();
34741 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 {
34746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34747 }
34748 return resultobj;
34749 fail:
34750 return NULL;
34751 }
34752
34753
34754 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34755 PyObject *resultobj = 0;
34756 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34757 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34758 bool result;
34759 void *argp1 = 0 ;
34760 int res1 = 0 ;
34761 void *argp2 = 0 ;
34762 int res2 = 0 ;
34763 PyObject * obj0 = 0 ;
34764 PyObject * obj1 = 0 ;
34765 char * kwnames[] = {
34766 (char *) "self",(char *) "other", NULL
34767 };
34768
34769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34771 if (!SWIG_IsOK(res1)) {
34772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34773 }
34774 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34776 if (!SWIG_IsOK(res2)) {
34777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34778 }
34779 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34780 {
34781 PyThreadState* __tstate = wxPyBeginAllowThreads();
34782 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34783 wxPyEndAllowThreads(__tstate);
34784 if (PyErr_Occurred()) SWIG_fail;
34785 }
34786 {
34787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34788 }
34789 return resultobj;
34790 fail:
34791 return NULL;
34792 }
34793
34794
34795 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34796 PyObject *resultobj = 0;
34797 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34798 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34799 bool result;
34800 void *argp1 = 0 ;
34801 int res1 = 0 ;
34802 void *argp2 = 0 ;
34803 int res2 = 0 ;
34804 PyObject * obj0 = 0 ;
34805 PyObject * obj1 = 0 ;
34806 char * kwnames[] = {
34807 (char *) "self",(char *) "other", NULL
34808 };
34809
34810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34812 if (!SWIG_IsOK(res1)) {
34813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34814 }
34815 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34817 if (!SWIG_IsOK(res2)) {
34818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34819 }
34820 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 {
34828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34829 }
34830 return resultobj;
34831 fail:
34832 return NULL;
34833 }
34834
34835
34836 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34837 PyObject *resultobj = 0;
34838 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34839 int arg2 ;
34840 void *argp1 = 0 ;
34841 int res1 = 0 ;
34842 int val2 ;
34843 int ecode2 = 0 ;
34844 PyObject *swig_obj[2] ;
34845
34846 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34848 if (!SWIG_IsOK(res1)) {
34849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34850 }
34851 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34852 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34853 if (!SWIG_IsOK(ecode2)) {
34854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34855 }
34856 arg2 = static_cast< int >(val2);
34857 if (arg1) (arg1)->w = arg2;
34858
34859 resultobj = SWIG_Py_Void();
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34867 PyObject *resultobj = 0;
34868 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34869 int result;
34870 void *argp1 = 0 ;
34871 int res1 = 0 ;
34872 PyObject *swig_obj[1] ;
34873
34874 if (!args) SWIG_fail;
34875 swig_obj[0] = args;
34876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34877 if (!SWIG_IsOK(res1)) {
34878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34879 }
34880 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34881 result = (int) ((arg1)->w);
34882 resultobj = SWIG_From_int(static_cast< int >(result));
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34890 PyObject *resultobj = 0;
34891 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34892 int arg2 ;
34893 void *argp1 = 0 ;
34894 int res1 = 0 ;
34895 int val2 ;
34896 int ecode2 = 0 ;
34897 PyObject *swig_obj[2] ;
34898
34899 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34901 if (!SWIG_IsOK(res1)) {
34902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34903 }
34904 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34905 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34906 if (!SWIG_IsOK(ecode2)) {
34907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34908 }
34909 arg2 = static_cast< int >(val2);
34910 if (arg1) (arg1)->h = arg2;
34911
34912 resultobj = SWIG_Py_Void();
34913 return resultobj;
34914 fail:
34915 return NULL;
34916 }
34917
34918
34919 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34920 PyObject *resultobj = 0;
34921 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34922 int result;
34923 void *argp1 = 0 ;
34924 int res1 = 0 ;
34925 PyObject *swig_obj[1] ;
34926
34927 if (!args) SWIG_fail;
34928 swig_obj[0] = args;
34929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34930 if (!SWIG_IsOK(res1)) {
34931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34932 }
34933 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34934 result = (int) ((arg1)->h);
34935 resultobj = SWIG_From_int(static_cast< int >(result));
34936 return resultobj;
34937 fail:
34938 return NULL;
34939 }
34940
34941
34942 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34943 PyObject *resultobj = 0;
34944 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34945 int arg2 ;
34946 void *argp1 = 0 ;
34947 int res1 = 0 ;
34948 int val2 ;
34949 int ecode2 = 0 ;
34950 PyObject *swig_obj[2] ;
34951
34952 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34954 if (!SWIG_IsOK(res1)) {
34955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34956 }
34957 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34958 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34959 if (!SWIG_IsOK(ecode2)) {
34960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34961 }
34962 arg2 = static_cast< int >(val2);
34963 if (arg1) (arg1)->bpp = arg2;
34964
34965 resultobj = SWIG_Py_Void();
34966 return resultobj;
34967 fail:
34968 return NULL;
34969 }
34970
34971
34972 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34973 PyObject *resultobj = 0;
34974 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34975 int result;
34976 void *argp1 = 0 ;
34977 int res1 = 0 ;
34978 PyObject *swig_obj[1] ;
34979
34980 if (!args) SWIG_fail;
34981 swig_obj[0] = args;
34982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34983 if (!SWIG_IsOK(res1)) {
34984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34985 }
34986 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34987 result = (int) ((arg1)->bpp);
34988 resultobj = SWIG_From_int(static_cast< int >(result));
34989 return resultobj;
34990 fail:
34991 return NULL;
34992 }
34993
34994
34995 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34996 PyObject *resultobj = 0;
34997 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34998 int arg2 ;
34999 void *argp1 = 0 ;
35000 int res1 = 0 ;
35001 int val2 ;
35002 int ecode2 = 0 ;
35003 PyObject *swig_obj[2] ;
35004
35005 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35007 if (!SWIG_IsOK(res1)) {
35008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35009 }
35010 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35011 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35012 if (!SWIG_IsOK(ecode2)) {
35013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35014 }
35015 arg2 = static_cast< int >(val2);
35016 if (arg1) (arg1)->refresh = arg2;
35017
35018 resultobj = SWIG_Py_Void();
35019 return resultobj;
35020 fail:
35021 return NULL;
35022 }
35023
35024
35025 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35026 PyObject *resultobj = 0;
35027 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35028 int result;
35029 void *argp1 = 0 ;
35030 int res1 = 0 ;
35031 PyObject *swig_obj[1] ;
35032
35033 if (!args) SWIG_fail;
35034 swig_obj[0] = args;
35035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35036 if (!SWIG_IsOK(res1)) {
35037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35038 }
35039 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35040 result = (int) ((arg1)->refresh);
35041 resultobj = SWIG_From_int(static_cast< int >(result));
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35049 PyObject *obj;
35050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35051 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35052 return SWIG_Py_Void();
35053 }
35054
35055 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35056 return SWIG_Python_InitShadowInstance(args);
35057 }
35058
35059 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35060 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35061 return 1;
35062 }
35063
35064
35065 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35066 PyObject *pyobj = 0;
35067
35068 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35069 return pyobj;
35070 }
35071
35072
35073 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35074 PyObject *resultobj = 0;
35075 size_t arg1 = (size_t) 0 ;
35076 wxDisplay *result = 0 ;
35077 size_t val1 ;
35078 int ecode1 = 0 ;
35079 PyObject * obj0 = 0 ;
35080 char * kwnames[] = {
35081 (char *) "index", NULL
35082 };
35083
35084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35085 if (obj0) {
35086 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35087 if (!SWIG_IsOK(ecode1)) {
35088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35089 }
35090 arg1 = static_cast< size_t >(val1);
35091 }
35092 {
35093 PyThreadState* __tstate = wxPyBeginAllowThreads();
35094 result = (wxDisplay *)new wxDisplay(arg1);
35095 wxPyEndAllowThreads(__tstate);
35096 if (PyErr_Occurred()) SWIG_fail;
35097 }
35098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35099 return resultobj;
35100 fail:
35101 return NULL;
35102 }
35103
35104
35105 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35106 PyObject *resultobj = 0;
35107 wxDisplay *arg1 = (wxDisplay *) 0 ;
35108 void *argp1 = 0 ;
35109 int res1 = 0 ;
35110 PyObject *swig_obj[1] ;
35111
35112 if (!args) SWIG_fail;
35113 swig_obj[0] = args;
35114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35115 if (!SWIG_IsOK(res1)) {
35116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35117 }
35118 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 delete arg1;
35122
35123 wxPyEndAllowThreads(__tstate);
35124 if (PyErr_Occurred()) SWIG_fail;
35125 }
35126 resultobj = SWIG_Py_Void();
35127 return resultobj;
35128 fail:
35129 return NULL;
35130 }
35131
35132
35133 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35134 PyObject *resultobj = 0;
35135 size_t result;
35136
35137 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35138 {
35139 PyThreadState* __tstate = wxPyBeginAllowThreads();
35140 result = (size_t)wxDisplay::GetCount();
35141 wxPyEndAllowThreads(__tstate);
35142 if (PyErr_Occurred()) SWIG_fail;
35143 }
35144 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35145 return resultobj;
35146 fail:
35147 return NULL;
35148 }
35149
35150
35151 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35152 PyObject *resultobj = 0;
35153 wxPoint *arg1 = 0 ;
35154 int result;
35155 wxPoint temp1 ;
35156 PyObject * obj0 = 0 ;
35157 char * kwnames[] = {
35158 (char *) "pt", NULL
35159 };
35160
35161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35162 {
35163 arg1 = &temp1;
35164 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35165 }
35166 {
35167 PyThreadState* __tstate = wxPyBeginAllowThreads();
35168 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35169 wxPyEndAllowThreads(__tstate);
35170 if (PyErr_Occurred()) SWIG_fail;
35171 }
35172 resultobj = SWIG_From_int(static_cast< int >(result));
35173 return resultobj;
35174 fail:
35175 return NULL;
35176 }
35177
35178
35179 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35180 PyObject *resultobj = 0;
35181 wxWindow *arg1 = (wxWindow *) 0 ;
35182 int result;
35183 void *argp1 = 0 ;
35184 int res1 = 0 ;
35185 PyObject * obj0 = 0 ;
35186 char * kwnames[] = {
35187 (char *) "window", NULL
35188 };
35189
35190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35192 if (!SWIG_IsOK(res1)) {
35193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35194 }
35195 arg1 = reinterpret_cast< wxWindow * >(argp1);
35196 {
35197 PyThreadState* __tstate = wxPyBeginAllowThreads();
35198 result = (int)wxDisplay::GetFromWindow(arg1);
35199 wxPyEndAllowThreads(__tstate);
35200 if (PyErr_Occurred()) SWIG_fail;
35201 }
35202 resultobj = SWIG_From_int(static_cast< int >(result));
35203 return resultobj;
35204 fail:
35205 return NULL;
35206 }
35207
35208
35209 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35210 PyObject *resultobj = 0;
35211 wxDisplay *arg1 = (wxDisplay *) 0 ;
35212 bool result;
35213 void *argp1 = 0 ;
35214 int res1 = 0 ;
35215 PyObject *swig_obj[1] ;
35216
35217 if (!args) SWIG_fail;
35218 swig_obj[0] = args;
35219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35220 if (!SWIG_IsOK(res1)) {
35221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35222 }
35223 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35224 {
35225 PyThreadState* __tstate = wxPyBeginAllowThreads();
35226 result = (bool)((wxDisplay const *)arg1)->IsOk();
35227 wxPyEndAllowThreads(__tstate);
35228 if (PyErr_Occurred()) SWIG_fail;
35229 }
35230 {
35231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35232 }
35233 return resultobj;
35234 fail:
35235 return NULL;
35236 }
35237
35238
35239 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35240 PyObject *resultobj = 0;
35241 wxDisplay *arg1 = (wxDisplay *) 0 ;
35242 wxRect result;
35243 void *argp1 = 0 ;
35244 int res1 = 0 ;
35245 PyObject *swig_obj[1] ;
35246
35247 if (!args) SWIG_fail;
35248 swig_obj[0] = args;
35249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35250 if (!SWIG_IsOK(res1)) {
35251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35252 }
35253 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35254 {
35255 PyThreadState* __tstate = wxPyBeginAllowThreads();
35256 result = ((wxDisplay const *)arg1)->GetGeometry();
35257 wxPyEndAllowThreads(__tstate);
35258 if (PyErr_Occurred()) SWIG_fail;
35259 }
35260 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35261 return resultobj;
35262 fail:
35263 return NULL;
35264 }
35265
35266
35267 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35268 PyObject *resultobj = 0;
35269 wxDisplay *arg1 = (wxDisplay *) 0 ;
35270 wxRect result;
35271 void *argp1 = 0 ;
35272 int res1 = 0 ;
35273 PyObject *swig_obj[1] ;
35274
35275 if (!args) SWIG_fail;
35276 swig_obj[0] = args;
35277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35278 if (!SWIG_IsOK(res1)) {
35279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35280 }
35281 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35282 {
35283 PyThreadState* __tstate = wxPyBeginAllowThreads();
35284 result = ((wxDisplay const *)arg1)->GetClientArea();
35285 wxPyEndAllowThreads(__tstate);
35286 if (PyErr_Occurred()) SWIG_fail;
35287 }
35288 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35289 return resultobj;
35290 fail:
35291 return NULL;
35292 }
35293
35294
35295 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35296 PyObject *resultobj = 0;
35297 wxDisplay *arg1 = (wxDisplay *) 0 ;
35298 wxString result;
35299 void *argp1 = 0 ;
35300 int res1 = 0 ;
35301 PyObject *swig_obj[1] ;
35302
35303 if (!args) SWIG_fail;
35304 swig_obj[0] = args;
35305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35306 if (!SWIG_IsOK(res1)) {
35307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35308 }
35309 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35310 {
35311 PyThreadState* __tstate = wxPyBeginAllowThreads();
35312 result = ((wxDisplay const *)arg1)->GetName();
35313 wxPyEndAllowThreads(__tstate);
35314 if (PyErr_Occurred()) SWIG_fail;
35315 }
35316 {
35317 #if wxUSE_UNICODE
35318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35319 #else
35320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35321 #endif
35322 }
35323 return resultobj;
35324 fail:
35325 return NULL;
35326 }
35327
35328
35329 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35330 PyObject *resultobj = 0;
35331 wxDisplay *arg1 = (wxDisplay *) 0 ;
35332 bool result;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 PyObject *swig_obj[1] ;
35336
35337 if (!args) SWIG_fail;
35338 swig_obj[0] = args;
35339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35340 if (!SWIG_IsOK(res1)) {
35341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35342 }
35343 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35344 {
35345 PyThreadState* __tstate = wxPyBeginAllowThreads();
35346 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35347 wxPyEndAllowThreads(__tstate);
35348 if (PyErr_Occurred()) SWIG_fail;
35349 }
35350 {
35351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35352 }
35353 return resultobj;
35354 fail:
35355 return NULL;
35356 }
35357
35358
35359 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35360 PyObject *resultobj = 0;
35361 wxDisplay *arg1 = (wxDisplay *) 0 ;
35362 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35363 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35364 PyObject *result = 0 ;
35365 void *argp1 = 0 ;
35366 int res1 = 0 ;
35367 void *argp2 = 0 ;
35368 int res2 = 0 ;
35369 PyObject * obj0 = 0 ;
35370 PyObject * obj1 = 0 ;
35371 char * kwnames[] = {
35372 (char *) "self",(char *) "mode", NULL
35373 };
35374
35375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35377 if (!SWIG_IsOK(res1)) {
35378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35379 }
35380 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35381 if (obj1) {
35382 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35383 if (!SWIG_IsOK(res2)) {
35384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35385 }
35386 if (!argp2) {
35387 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35388 }
35389 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35390 }
35391 {
35392 PyThreadState* __tstate = wxPyBeginAllowThreads();
35393 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35394 wxPyEndAllowThreads(__tstate);
35395 if (PyErr_Occurred()) SWIG_fail;
35396 }
35397 resultobj = result;
35398 return resultobj;
35399 fail:
35400 return NULL;
35401 }
35402
35403
35404 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35405 PyObject *resultobj = 0;
35406 wxDisplay *arg1 = (wxDisplay *) 0 ;
35407 wxVideoMode result;
35408 void *argp1 = 0 ;
35409 int res1 = 0 ;
35410 PyObject *swig_obj[1] ;
35411
35412 if (!args) SWIG_fail;
35413 swig_obj[0] = args;
35414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35415 if (!SWIG_IsOK(res1)) {
35416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35417 }
35418 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35419 {
35420 PyThreadState* __tstate = wxPyBeginAllowThreads();
35421 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35422 wxPyEndAllowThreads(__tstate);
35423 if (PyErr_Occurred()) SWIG_fail;
35424 }
35425 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35426 return resultobj;
35427 fail:
35428 return NULL;
35429 }
35430
35431
35432 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35433 PyObject *resultobj = 0;
35434 wxDisplay *arg1 = (wxDisplay *) 0 ;
35435 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35436 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35437 bool result;
35438 void *argp1 = 0 ;
35439 int res1 = 0 ;
35440 void *argp2 = 0 ;
35441 int res2 = 0 ;
35442 PyObject * obj0 = 0 ;
35443 PyObject * obj1 = 0 ;
35444 char * kwnames[] = {
35445 (char *) "self",(char *) "mode", NULL
35446 };
35447
35448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35450 if (!SWIG_IsOK(res1)) {
35451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35452 }
35453 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35454 if (obj1) {
35455 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35456 if (!SWIG_IsOK(res2)) {
35457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35458 }
35459 if (!argp2) {
35460 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35461 }
35462 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35463 }
35464 {
35465 PyThreadState* __tstate = wxPyBeginAllowThreads();
35466 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35467 wxPyEndAllowThreads(__tstate);
35468 if (PyErr_Occurred()) SWIG_fail;
35469 }
35470 {
35471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35472 }
35473 return resultobj;
35474 fail:
35475 return NULL;
35476 }
35477
35478
35479 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35480 PyObject *resultobj = 0;
35481 wxDisplay *arg1 = (wxDisplay *) 0 ;
35482 void *argp1 = 0 ;
35483 int res1 = 0 ;
35484 PyObject *swig_obj[1] ;
35485
35486 if (!args) SWIG_fail;
35487 swig_obj[0] = args;
35488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35489 if (!SWIG_IsOK(res1)) {
35490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35491 }
35492 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35493 {
35494 PyThreadState* __tstate = wxPyBeginAllowThreads();
35495 wxDisplay_ResetMode(arg1);
35496 wxPyEndAllowThreads(__tstate);
35497 if (PyErr_Occurred()) SWIG_fail;
35498 }
35499 resultobj = SWIG_Py_Void();
35500 return resultobj;
35501 fail:
35502 return NULL;
35503 }
35504
35505
35506 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35507 PyObject *obj;
35508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35509 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35510 return SWIG_Py_Void();
35511 }
35512
35513 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35514 return SWIG_Python_InitShadowInstance(args);
35515 }
35516
35517 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35518 PyObject *resultobj = 0;
35519 wxStandardPaths *result = 0 ;
35520
35521 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35522 {
35523 PyThreadState* __tstate = wxPyBeginAllowThreads();
35524 result = (wxStandardPaths *)wxStandardPaths_Get();
35525 wxPyEndAllowThreads(__tstate);
35526 if (PyErr_Occurred()) SWIG_fail;
35527 }
35528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35529 return resultobj;
35530 fail:
35531 return NULL;
35532 }
35533
35534
35535 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35536 PyObject *resultobj = 0;
35537 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35538 wxString result;
35539 void *argp1 = 0 ;
35540 int res1 = 0 ;
35541 PyObject *swig_obj[1] ;
35542
35543 if (!args) SWIG_fail;
35544 swig_obj[0] = args;
35545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35546 if (!SWIG_IsOK(res1)) {
35547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35548 }
35549 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35550 {
35551 PyThreadState* __tstate = wxPyBeginAllowThreads();
35552 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35553 wxPyEndAllowThreads(__tstate);
35554 if (PyErr_Occurred()) SWIG_fail;
35555 }
35556 {
35557 #if wxUSE_UNICODE
35558 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35559 #else
35560 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35561 #endif
35562 }
35563 return resultobj;
35564 fail:
35565 return NULL;
35566 }
35567
35568
35569 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35570 PyObject *resultobj = 0;
35571 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35572 wxString result;
35573 void *argp1 = 0 ;
35574 int res1 = 0 ;
35575 PyObject *swig_obj[1] ;
35576
35577 if (!args) SWIG_fail;
35578 swig_obj[0] = args;
35579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35580 if (!SWIG_IsOK(res1)) {
35581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35582 }
35583 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35584 {
35585 PyThreadState* __tstate = wxPyBeginAllowThreads();
35586 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35587 wxPyEndAllowThreads(__tstate);
35588 if (PyErr_Occurred()) SWIG_fail;
35589 }
35590 {
35591 #if wxUSE_UNICODE
35592 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35593 #else
35594 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35595 #endif
35596 }
35597 return resultobj;
35598 fail:
35599 return NULL;
35600 }
35601
35602
35603 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35604 PyObject *resultobj = 0;
35605 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35606 wxString result;
35607 void *argp1 = 0 ;
35608 int res1 = 0 ;
35609 PyObject *swig_obj[1] ;
35610
35611 if (!args) SWIG_fail;
35612 swig_obj[0] = args;
35613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35614 if (!SWIG_IsOK(res1)) {
35615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35616 }
35617 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35618 {
35619 PyThreadState* __tstate = wxPyBeginAllowThreads();
35620 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35621 wxPyEndAllowThreads(__tstate);
35622 if (PyErr_Occurred()) SWIG_fail;
35623 }
35624 {
35625 #if wxUSE_UNICODE
35626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35627 #else
35628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35629 #endif
35630 }
35631 return resultobj;
35632 fail:
35633 return NULL;
35634 }
35635
35636
35637 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35638 PyObject *resultobj = 0;
35639 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35640 wxString result;
35641 void *argp1 = 0 ;
35642 int res1 = 0 ;
35643 PyObject *swig_obj[1] ;
35644
35645 if (!args) SWIG_fail;
35646 swig_obj[0] = args;
35647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35648 if (!SWIG_IsOK(res1)) {
35649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35650 }
35651 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35652 {
35653 PyThreadState* __tstate = wxPyBeginAllowThreads();
35654 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35655 wxPyEndAllowThreads(__tstate);
35656 if (PyErr_Occurred()) SWIG_fail;
35657 }
35658 {
35659 #if wxUSE_UNICODE
35660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35661 #else
35662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35663 #endif
35664 }
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35672 PyObject *resultobj = 0;
35673 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35674 wxString result;
35675 void *argp1 = 0 ;
35676 int res1 = 0 ;
35677 PyObject *swig_obj[1] ;
35678
35679 if (!args) SWIG_fail;
35680 swig_obj[0] = args;
35681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35682 if (!SWIG_IsOK(res1)) {
35683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35684 }
35685 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35686 {
35687 PyThreadState* __tstate = wxPyBeginAllowThreads();
35688 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35689 wxPyEndAllowThreads(__tstate);
35690 if (PyErr_Occurred()) SWIG_fail;
35691 }
35692 {
35693 #if wxUSE_UNICODE
35694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35695 #else
35696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35697 #endif
35698 }
35699 return resultobj;
35700 fail:
35701 return NULL;
35702 }
35703
35704
35705 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35706 PyObject *resultobj = 0;
35707 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35708 wxString result;
35709 void *argp1 = 0 ;
35710 int res1 = 0 ;
35711 PyObject *swig_obj[1] ;
35712
35713 if (!args) SWIG_fail;
35714 swig_obj[0] = args;
35715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35716 if (!SWIG_IsOK(res1)) {
35717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35718 }
35719 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35720 {
35721 PyThreadState* __tstate = wxPyBeginAllowThreads();
35722 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35723 wxPyEndAllowThreads(__tstate);
35724 if (PyErr_Occurred()) SWIG_fail;
35725 }
35726 {
35727 #if wxUSE_UNICODE
35728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35729 #else
35730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35731 #endif
35732 }
35733 return resultobj;
35734 fail:
35735 return NULL;
35736 }
35737
35738
35739 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35740 PyObject *resultobj = 0;
35741 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35742 wxString result;
35743 void *argp1 = 0 ;
35744 int res1 = 0 ;
35745 PyObject *swig_obj[1] ;
35746
35747 if (!args) SWIG_fail;
35748 swig_obj[0] = args;
35749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35750 if (!SWIG_IsOK(res1)) {
35751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35752 }
35753 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35754 {
35755 PyThreadState* __tstate = wxPyBeginAllowThreads();
35756 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 {
35761 #if wxUSE_UNICODE
35762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35763 #else
35764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35765 #endif
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35774 PyObject *resultobj = 0;
35775 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35776 wxString result;
35777 void *argp1 = 0 ;
35778 int res1 = 0 ;
35779 PyObject *swig_obj[1] ;
35780
35781 if (!args) SWIG_fail;
35782 swig_obj[0] = args;
35783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35784 if (!SWIG_IsOK(res1)) {
35785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35786 }
35787 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35788 {
35789 PyThreadState* __tstate = wxPyBeginAllowThreads();
35790 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35791 wxPyEndAllowThreads(__tstate);
35792 if (PyErr_Occurred()) SWIG_fail;
35793 }
35794 {
35795 #if wxUSE_UNICODE
35796 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35797 #else
35798 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35799 #endif
35800 }
35801 return resultobj;
35802 fail:
35803 return NULL;
35804 }
35805
35806
35807 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35808 PyObject *resultobj = 0;
35809 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35810 wxString *arg2 = 0 ;
35811 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35812 wxString result;
35813 void *argp1 = 0 ;
35814 int res1 = 0 ;
35815 bool temp2 = false ;
35816 int val3 ;
35817 int ecode3 = 0 ;
35818 PyObject * obj0 = 0 ;
35819 PyObject * obj1 = 0 ;
35820 PyObject * obj2 = 0 ;
35821 char * kwnames[] = {
35822 (char *) "self",(char *) "lang",(char *) "category", NULL
35823 };
35824
35825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35827 if (!SWIG_IsOK(res1)) {
35828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35829 }
35830 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35831 {
35832 arg2 = wxString_in_helper(obj1);
35833 if (arg2 == NULL) SWIG_fail;
35834 temp2 = true;
35835 }
35836 if (obj2) {
35837 ecode3 = SWIG_AsVal_int(obj2, &val3);
35838 if (!SWIG_IsOK(ecode3)) {
35839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35840 }
35841 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35842 }
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 {
35850 #if wxUSE_UNICODE
35851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35852 #else
35853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35854 #endif
35855 }
35856 {
35857 if (temp2)
35858 delete arg2;
35859 }
35860 return resultobj;
35861 fail:
35862 {
35863 if (temp2)
35864 delete arg2;
35865 }
35866 return NULL;
35867 }
35868
35869
35870 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35871 PyObject *resultobj = 0;
35872 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35873 wxString result;
35874 void *argp1 = 0 ;
35875 int res1 = 0 ;
35876 PyObject *swig_obj[1] ;
35877
35878 if (!args) SWIG_fail;
35879 swig_obj[0] = args;
35880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35881 if (!SWIG_IsOK(res1)) {
35882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35883 }
35884 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35885 {
35886 PyThreadState* __tstate = wxPyBeginAllowThreads();
35887 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35888 wxPyEndAllowThreads(__tstate);
35889 if (PyErr_Occurred()) SWIG_fail;
35890 }
35891 {
35892 #if wxUSE_UNICODE
35893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35894 #else
35895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35896 #endif
35897 }
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj = 0;
35906 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35907 wxString *arg2 = 0 ;
35908 void *argp1 = 0 ;
35909 int res1 = 0 ;
35910 bool temp2 = false ;
35911 PyObject * obj0 = 0 ;
35912 PyObject * obj1 = 0 ;
35913 char * kwnames[] = {
35914 (char *) "self",(char *) "prefix", NULL
35915 };
35916
35917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35919 if (!SWIG_IsOK(res1)) {
35920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35921 }
35922 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35923 {
35924 arg2 = wxString_in_helper(obj1);
35925 if (arg2 == NULL) SWIG_fail;
35926 temp2 = true;
35927 }
35928 {
35929 PyThreadState* __tstate = wxPyBeginAllowThreads();
35930 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 resultobj = SWIG_Py_Void();
35935 {
35936 if (temp2)
35937 delete arg2;
35938 }
35939 return resultobj;
35940 fail:
35941 {
35942 if (temp2)
35943 delete arg2;
35944 }
35945 return NULL;
35946 }
35947
35948
35949 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35950 PyObject *resultobj = 0;
35951 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35952 wxString result;
35953 void *argp1 = 0 ;
35954 int res1 = 0 ;
35955 PyObject *swig_obj[1] ;
35956
35957 if (!args) SWIG_fail;
35958 swig_obj[0] = args;
35959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35960 if (!SWIG_IsOK(res1)) {
35961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35962 }
35963 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35964 {
35965 PyThreadState* __tstate = wxPyBeginAllowThreads();
35966 result = wxStandardPaths_GetInstallPrefix(arg1);
35967 wxPyEndAllowThreads(__tstate);
35968 if (PyErr_Occurred()) SWIG_fail;
35969 }
35970 {
35971 #if wxUSE_UNICODE
35972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35973 #else
35974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35975 #endif
35976 }
35977 return resultobj;
35978 fail:
35979 return NULL;
35980 }
35981
35982
35983 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35984 PyObject *obj;
35985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35986 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35987 return SWIG_Py_Void();
35988 }
35989
35990 static PyMethodDef SwigMethods[] = {
35991 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
35992 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35993 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
35994 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
35995 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
35996 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
35997 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
35998 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
35999 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36000 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36001 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36002 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36003 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36004 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36005 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36006 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36007 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36008 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36009 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36010 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36011 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36012 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36013 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36014 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36015 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36016 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36017 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36018 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36019 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36020 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36021 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36022 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36023 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36024 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36025 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36026 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36027 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36028 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36029 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36030 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36031 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36032 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36033 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36034 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36035 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36036 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36037 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36038 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36039 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36040 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36041 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36042 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36043 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36044 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36045 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36046 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36047 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36048 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36049 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36050 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36051 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36052 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36053 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36054 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36055 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36056 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36057 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36058 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36059 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36060 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36061 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36062 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36063 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36064 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36065 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36066 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36067 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36068 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36069 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36070 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36071 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36072 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36073 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36074 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36075 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36076 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36077 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36078 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36079 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36080 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36081 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36082 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36083 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36084 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36085 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36086 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36087 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36088 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36089 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36090 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36091 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36092 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36093 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36094 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36095 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36096 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36097 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36098 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36099 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36100 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36101 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36102 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36103 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36104 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36105 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36106 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36107 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36108 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36109 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36110 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36111 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36112 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36113 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36114 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36115 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36116 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36117 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36118 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36119 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36120 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36121 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36122 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36123 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36124 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36125 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36126 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36127 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36128 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36129 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36130 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36131 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36132 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36133 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36134 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36135 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36136 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36137 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36138 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36139 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36140 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36141 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36142 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36143 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36144 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36145 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36146 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36147 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36148 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36149 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36150 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36151 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36152 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36153 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36154 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36156 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36157 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36159 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36160 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36161 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36162 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36163 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36164 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36165 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36167 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36168 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36169 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36170 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36171 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36172 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36173 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36174 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36175 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36176 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36177 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36178 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36179 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36180 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36182 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36183 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36184 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36185 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36186 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36187 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36188 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36189 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36190 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36191 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36192 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36193 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36194 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36195 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36196 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36197 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36198 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36199 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36200 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36201 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36202 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36203 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36204 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36205 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36206 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36207 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36208 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36209 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36210 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36211 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36212 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36213 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36214 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36215 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36216 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36217 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36218 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36219 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36221 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36222 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36223 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36224 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36225 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36226 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36227 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36228 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36229 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36230 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36231 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36232 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36233 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36234 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36235 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36236 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36237 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36238 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36239 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36240 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36241 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36242 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36243 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36244 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36245 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36246 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36247 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36248 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36249 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36250 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36252 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36253 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36254 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36255 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36256 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36257 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36258 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36259 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36260 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36261 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36262 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36263 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36264 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36265 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36267 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36268 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36270 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36271 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36274 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36275 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36277 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36278 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36279 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36280 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36281 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36282 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36283 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36284 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36289 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36291 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36292 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36293 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36294 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36295 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36296 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36297 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36298 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36299 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36300 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36301 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36302 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36304 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36305 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36306 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36307 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36308 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36309 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36310 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36311 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36315 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36316 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36317 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36318 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36319 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36320 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36321 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36322 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36323 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36324 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36326 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36327 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36328 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36329 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36330 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36331 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36332 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36333 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36334 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36335 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36336 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36337 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36338 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36339 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36340 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36341 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36342 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36343 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36344 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36345 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36346 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36347 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36348 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36349 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36350 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36351 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36352 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36353 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36354 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36355 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36357 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36358 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36359 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36361 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36362 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36363 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36364 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36365 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36371 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36372 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36373 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36377 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36378 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36379 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36381 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36384 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36386 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36387 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36388 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36389 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36392 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36393 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36394 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36396 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36397 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36398 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36399 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36400 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36401 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36402 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36403 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36404 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36405 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36406 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36408 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36409 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36410 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36411 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36412 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36413 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36414 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36419 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36420 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36422 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36423 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36425 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36426 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36427 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36432 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36434 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36436 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36437 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36438 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36439 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36440 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36443 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36444 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36447 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36448 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36449 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36450 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36451 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36453 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36454 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36455 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36457 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36458 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36459 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36460 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36463 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36464 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36468 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36473 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36479 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36480 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36481 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36483 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36485 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36487 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36488 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36492 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36493 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36494 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36495 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36496 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36497 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36499 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36500 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36501 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36502 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36503 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36504 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36505 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36506 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36507 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36508 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36509 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36510 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36511 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36514 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36515 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36516 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36518 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36519 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36520 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36524 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36525 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36526 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36527 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36533 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36534 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36535 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36537 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36539 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36540 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36541 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36546 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36553 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36555 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36557 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36558 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36559 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36561 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36563 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36564 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36565 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36566 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36567 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36573 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36577 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36578 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36579 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36580 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36584 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36593 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36595 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36596 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36600 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36601 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36606 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36607 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36608 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36609 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36617 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36618 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36619 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36621 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36622 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36623 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36624 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36625 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36626 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36627 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36629 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36630 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36631 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36633 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36635 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36636 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36637 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36639 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36640 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36641 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36645 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36646 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36649 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36650 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36656 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36657 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36658 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36659 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36661 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36662 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36663 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36667 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36668 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36669 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36670 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36671 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36672 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36673 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36674 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36675 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36676 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36677 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36678 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36679 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36680 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36681 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36682 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36683 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36684 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36685 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36688 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36689 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36690 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36691 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36692 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36693 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36694 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36697 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36700 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36701 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36709 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36710 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36711 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36712 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36713 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36714 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36716 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36717 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36718 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36719 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36720 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36721 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36722 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36723 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36724 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36725 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36726 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36727 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36728 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36734 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36736 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36737 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36738 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36739 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36741 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36742 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36745 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36746 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36747 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36749 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36750 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36751 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36753 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36754 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36756 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36757 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36760 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36761 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36763 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36765 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36766 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36769 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36770 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36771 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36772 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36773 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36774 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36775 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36776 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36777 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36778 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36779 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36780 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36781 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36782 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36783 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36784 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36785 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36786 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36787 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
36788 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
36789 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36790 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36791 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36795 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36797 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36798 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36801 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36802 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36805 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36806 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36810 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36812 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36814 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36815 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36816 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36817 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36822 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36825 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36826 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36827 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36832 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36834 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36835 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36836 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36837 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36838 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36839 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36840 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36841 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36842 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36843 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36844 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36845 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36846 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36847 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36848 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36849 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36850 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36851 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36853 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36854 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36855 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36856 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36857 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36858 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36860 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36861 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36862 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36863 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36864 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36865 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36866 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36867 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36868 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36869 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36870 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36871 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36872 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36873 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36874 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36875 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36877 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36878 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36881 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36882 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
36883 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36884 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36885 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36886 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36887 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36889 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36890 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36891 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36892 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36893 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36894 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36895 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36896 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36897 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36898 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36899 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
36900 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
36902 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36903 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36904 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36905 { NULL, NULL, 0, NULL }
36906 };
36907
36908
36909 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
36910
36911 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
36912 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
36913 }
36914 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
36915 return (void *)((wxEvent *) ((wxMenuEvent *) x));
36916 }
36917 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
36918 return (void *)((wxEvent *) ((wxCloseEvent *) x));
36919 }
36920 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
36921 return (void *)((wxEvent *) ((wxMouseEvent *) x));
36922 }
36923 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
36924 return (void *)((wxEvent *) ((wxEraseEvent *) x));
36925 }
36926 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
36927 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
36928 }
36929 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
36930 return (void *)((wxEvent *) ((wxTimerEvent *) x));
36931 }
36932 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
36933 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
36934 }
36935 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
36936 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
36937 }
36938 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
36939 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
36940 }
36941 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
36942 return (void *)((wxEvent *) ((wxPyEvent *) x));
36943 }
36944 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
36945 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
36946 }
36947 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
36948 return (void *)((wxEvent *) ((wxIdleEvent *) x));
36949 }
36950 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
36951 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
36952 }
36953 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
36954 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
36955 }
36956 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
36957 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
36958 }
36959 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
36960 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
36961 }
36962 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
36963 return (void *)((wxEvent *) ((wxActivateEvent *) x));
36964 }
36965 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
36966 return (void *)((wxEvent *) ((wxSizeEvent *) x));
36967 }
36968 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
36969 return (void *)((wxEvent *) ((wxMoveEvent *) x));
36970 }
36971 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
36972 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
36973 }
36974 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
36975 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
36976 }
36977 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
36978 return (void *)((wxEvent *) ((wxPaintEvent *) x));
36979 }
36980 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
36981 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
36982 }
36983 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
36984 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
36985 }
36986 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
36987 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
36988 }
36989 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
36990 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
36991 }
36992 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
36993 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36994 }
36995 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
36996 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
36997 }
36998 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
36999 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37000 }
37001 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37002 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37003 }
37004 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37005 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37006 }
37007 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37008 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37009 }
37010 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37011 return (void *)((wxEvent *) ((wxShowEvent *) x));
37012 }
37013 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37014 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37015 }
37016 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37017 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37018 }
37019 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37020 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37021 }
37022 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37023 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37024 }
37025 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37026 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37027 }
37028 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37029 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37030 }
37031 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37032 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37033 }
37034 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37035 return (void *)((wxConfigBase *) ((wxConfig *) x));
37036 }
37037 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37038 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37039 }
37040 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37041 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37042 }
37043 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37044 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37045 }
37046 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37047 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37048 }
37049 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37050 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37051 }
37052 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37053 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37054 }
37055 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37056 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37057 }
37058 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37059 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37060 }
37061 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37062 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37063 }
37064 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37065 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37066 }
37067 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37068 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37069 }
37070 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37071 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37072 }
37073 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37074 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37075 }
37076 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37077 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37078 }
37079 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37080 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37081 }
37082 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37083 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37084 }
37085 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37086 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37087 }
37088 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37089 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37090 }
37091 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37092 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37093 }
37094 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37095 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37096 }
37097 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37098 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37099 }
37100 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37101 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37102 }
37103 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37104 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37105 }
37106 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37107 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37108 }
37109 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37110 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37111 }
37112 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37113 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37114 }
37115 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37116 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37117 }
37118 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37119 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37120 }
37121 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37122 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37123 }
37124 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37125 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37126 }
37127 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37128 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37129 }
37130 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37131 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37132 }
37133 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37134 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37135 }
37136 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37137 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37138 }
37139 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37140 return (void *)((wxObject *) ((wxSizerItem *) x));
37141 }
37142 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37143 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37144 }
37145 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37146 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37147 }
37148 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37149 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37150 }
37151 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37152 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37153 }
37154 static void *_p_wxSizerTo_p_wxObject(void *x) {
37155 return (void *)((wxObject *) ((wxSizer *) x));
37156 }
37157 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37158 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37159 }
37160 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37161 return (void *)((wxObject *) ((wxFileHistory *) x));
37162 }
37163 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37164 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37165 }
37166 static void *_p_wxEventTo_p_wxObject(void *x) {
37167 return (void *)((wxObject *) ((wxEvent *) x));
37168 }
37169 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37170 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37171 }
37172 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37173 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37174 }
37175 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37176 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37177 }
37178 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37179 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37180 }
37181 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37182 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37183 }
37184 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37185 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37186 }
37187 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37188 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37189 }
37190 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37191 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37192 }
37193 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37194 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37195 }
37196 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37197 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37198 }
37199 static void *_p_wxControlTo_p_wxObject(void *x) {
37200 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37201 }
37202 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37203 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37204 }
37205 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37206 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37207 }
37208 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37209 return (void *)((wxObject *) ((wxFSFile *) x));
37210 }
37211 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37212 return (void *)((wxObject *) ((wxClipboard *) x));
37213 }
37214 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37215 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37216 }
37217 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37218 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37219 }
37220 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37221 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37222 }
37223 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37224 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37225 }
37226 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37227 return (void *)((wxObject *) ((wxToolTip *) x));
37228 }
37229 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37230 return (void *)((wxObject *) ((wxMenuItem *) x));
37231 }
37232 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37233 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37234 }
37235 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37236 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37237 }
37238 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37239 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37240 }
37241 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37242 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37243 }
37244 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37245 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37246 }
37247 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37248 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37249 }
37250 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37251 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37252 }
37253 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37254 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37255 }
37256 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37257 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37258 }
37259 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37260 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37261 }
37262 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37263 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37264 }
37265 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37266 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37267 }
37268 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37269 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37270 }
37271 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37272 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37273 }
37274 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37275 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37276 }
37277 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37278 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37279 }
37280 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37281 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37282 }
37283 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37284 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37285 }
37286 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37287 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37288 }
37289 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37290 return (void *)((wxObject *) ((wxImageHandler *) x));
37291 }
37292 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37293 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37294 }
37295 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37296 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37297 }
37298 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37299 return (void *)((wxObject *) ((wxEvtHandler *) x));
37300 }
37301 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37302 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37303 }
37304 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37305 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37306 }
37307 static void *_p_wxImageTo_p_wxObject(void *x) {
37308 return (void *)((wxObject *) ((wxImage *) x));
37309 }
37310 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37311 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37312 }
37313 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37314 return (void *)((wxObject *) ((wxSystemOptions *) x));
37315 }
37316 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37317 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37318 }
37319 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37320 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37321 }
37322 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37323 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37324 }
37325 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37326 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37327 }
37328 static void *_p_wxWindowTo_p_wxObject(void *x) {
37329 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37330 }
37331 static void *_p_wxMenuTo_p_wxObject(void *x) {
37332 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37333 }
37334 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37335 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37336 }
37337 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37338 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37339 }
37340 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37341 return (void *)((wxObject *) ((wxFileSystem *) x));
37342 }
37343 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37344 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37345 }
37346 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37347 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37348 }
37349 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37350 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37351 }
37352 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37353 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37354 }
37355 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37356 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37357 }
37358 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37359 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37360 }
37361 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37362 return (void *)((wxObject *) ((wxBusyInfo *) x));
37363 }
37364 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37365 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37366 }
37367 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37368 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37369 }
37370 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37371 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37372 }
37373 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37374 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37375 }
37376 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37377 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37378 }
37379 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37380 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37381 }
37382 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37383 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37384 }
37385 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37386 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37387 }
37388 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37389 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37390 }
37391 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37392 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37393 }
37394 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37395 return (void *)((wxLog *) ((wxLogBuffer *) x));
37396 }
37397 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37398 return (void *)((wxLog *) ((wxLogStderr *) x));
37399 }
37400 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37401 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37402 }
37403 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37404 return (void *)((wxLog *) ((wxLogWindow *) x));
37405 }
37406 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37407 return (void *)((wxLog *) ((wxLogChain *) x));
37408 }
37409 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37410 return (void *)((wxLog *) ((wxLogGui *) x));
37411 }
37412 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37413 return (void *)((wxLog *) ((wxPyLog *) x));
37414 }
37415 static void *_p_wxControlTo_p_wxWindow(void *x) {
37416 return (void *)((wxWindow *) ((wxControl *) x));
37417 }
37418 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37419 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37420 }
37421 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37422 return (void *)((wxWindow *) ((wxMenuBar *) x));
37423 }
37424 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37425 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37426 }
37427 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37428 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37429 }
37430 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37431 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};
37432 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37433 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37434 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37435 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37436 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37437 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37438 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37439 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37440 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37441 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37442 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37443 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37444 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37445 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37446 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37447 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37448 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37449 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37450 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37451 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37452 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37453 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37454 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37455 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37456 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37457 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37458 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37459 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37460 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37461 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37462 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37463 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37464 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37465 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37466 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37467 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37468 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37469 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37470 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37471 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37472 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37473 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37474 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37475 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37476 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37477 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37478 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37479 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37480 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37481 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37482 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37483 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37484 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37485 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37486 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37487 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37488 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37489 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37490 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37491 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37492 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37493 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37494 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37495 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37496 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37497 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37498 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37499 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37500 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37501 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37502 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37503 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37504 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37505 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37506 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37507 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37508 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37509 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37510 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37511 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37512 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37513 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37514 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37515 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37516 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37517 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37518 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37519 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37520 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37521 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37522 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37523 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37524 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37525 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37526 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37527 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37528 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37529 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37530 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37531 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37532 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37533 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37534 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37535 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37536 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37537 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37538 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37539 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37540 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37541 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37542 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37543 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37544 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37545 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37546 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37547 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37548 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37549 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37550 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37551 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37552 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37553 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37554 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37555 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37556 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37557 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37558 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37559 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37560 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37561 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37562 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37563 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37564 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37565 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37566 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37567 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37568 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37569 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37570 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37571 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37572 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37573 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37574 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37575 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37576 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37577 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37578 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37579 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37580 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37581 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37582 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37583 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37584 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37585 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37586 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37587 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37588 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37589 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37590 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37591 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37592 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37593 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37594 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37595 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37596 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37597 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37598 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37599 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37600 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37601
37602 static swig_type_info *swig_type_initial[] = {
37603 &_swigt__p_char,
37604 &_swigt__p_form_ops_t,
37605 &_swigt__p_int,
37606 &_swigt__p_unsigned_char,
37607 &_swigt__p_unsigned_int,
37608 &_swigt__p_unsigned_long,
37609 &_swigt__p_void,
37610 &_swigt__p_wxANIHandler,
37611 &_swigt__p_wxAcceleratorTable,
37612 &_swigt__p_wxActivateEvent,
37613 &_swigt__p_wxArrayString,
37614 &_swigt__p_wxBMPHandler,
37615 &_swigt__p_wxBitmap,
37616 &_swigt__p_wxBitmapDataObject,
37617 &_swigt__p_wxBoxSizer,
37618 &_swigt__p_wxBusyCursor,
37619 &_swigt__p_wxBusyInfo,
37620 &_swigt__p_wxCURHandler,
37621 &_swigt__p_wxCaret,
37622 &_swigt__p_wxChar,
37623 &_swigt__p_wxChildFocusEvent,
37624 &_swigt__p_wxClipboard,
37625 &_swigt__p_wxClipboardLocker,
37626 &_swigt__p_wxClipboardTextEvent,
37627 &_swigt__p_wxCloseEvent,
37628 &_swigt__p_wxColour,
37629 &_swigt__p_wxCommandEvent,
37630 &_swigt__p_wxConfig,
37631 &_swigt__p_wxConfigBase,
37632 &_swigt__p_wxConfigPathChanger,
37633 &_swigt__p_wxContextMenuEvent,
37634 &_swigt__p_wxControl,
37635 &_swigt__p_wxControlWithItems,
37636 &_swigt__p_wxCursor,
37637 &_swigt__p_wxCustomDataObject,
37638 &_swigt__p_wxDC,
37639 &_swigt__p_wxDataFormat,
37640 &_swigt__p_wxDataObject,
37641 &_swigt__p_wxDataObjectComposite,
37642 &_swigt__p_wxDataObjectSimple,
37643 &_swigt__p_wxDateEvent,
37644 &_swigt__p_wxDateSpan,
37645 &_swigt__p_wxDateTime,
37646 &_swigt__p_wxDateTime__TimeZone,
37647 &_swigt__p_wxDisplay,
37648 &_swigt__p_wxDisplayChangedEvent,
37649 &_swigt__p_wxDropFilesEvent,
37650 &_swigt__p_wxDuplexMode,
37651 &_swigt__p_wxEraseEvent,
37652 &_swigt__p_wxEvent,
37653 &_swigt__p_wxEvtHandler,
37654 &_swigt__p_wxFSFile,
37655 &_swigt__p_wxFileConfig,
37656 &_swigt__p_wxFileDataObject,
37657 &_swigt__p_wxFileHistory,
37658 &_swigt__p_wxFileSystem,
37659 &_swigt__p_wxFileType,
37660 &_swigt__p_wxFileTypeInfo,
37661 &_swigt__p_wxFlexGridSizer,
37662 &_swigt__p_wxFocusEvent,
37663 &_swigt__p_wxFont,
37664 &_swigt__p_wxFrame,
37665 &_swigt__p_wxGBSizerItem,
37666 &_swigt__p_wxGIFHandler,
37667 &_swigt__p_wxGridBagSizer,
37668 &_swigt__p_wxGridSizer,
37669 &_swigt__p_wxICOHandler,
37670 &_swigt__p_wxIcon,
37671 &_swigt__p_wxIconizeEvent,
37672 &_swigt__p_wxIdleEvent,
37673 &_swigt__p_wxImage,
37674 &_swigt__p_wxImageHandler,
37675 &_swigt__p_wxIndividualLayoutConstraint,
37676 &_swigt__p_wxInitDialogEvent,
37677 &_swigt__p_wxJPEGHandler,
37678 &_swigt__p_wxJoystick,
37679 &_swigt__p_wxJoystickEvent,
37680 &_swigt__p_wxKeyEvent,
37681 &_swigt__p_wxKillError,
37682 &_swigt__p_wxLayoutConstraints,
37683 &_swigt__p_wxLog,
37684 &_swigt__p_wxLogBuffer,
37685 &_swigt__p_wxLogChain,
37686 &_swigt__p_wxLogGui,
37687 &_swigt__p_wxLogNull,
37688 &_swigt__p_wxLogStderr,
37689 &_swigt__p_wxLogTextCtrl,
37690 &_swigt__p_wxLogWindow,
37691 &_swigt__p_wxMaximizeEvent,
37692 &_swigt__p_wxMemorySize,
37693 &_swigt__p_wxMenu,
37694 &_swigt__p_wxMenuBar,
37695 &_swigt__p_wxMenuEvent,
37696 &_swigt__p_wxMenuItem,
37697 &_swigt__p_wxMetafile,
37698 &_swigt__p_wxMetafileDataObject,
37699 &_swigt__p_wxMimeTypesManager,
37700 &_swigt__p_wxMouseCaptureChangedEvent,
37701 &_swigt__p_wxMouseEvent,
37702 &_swigt__p_wxMouseState,
37703 &_swigt__p_wxMoveEvent,
37704 &_swigt__p_wxMutexGuiLocker,
37705 &_swigt__p_wxNavigationKeyEvent,
37706 &_swigt__p_wxNcPaintEvent,
37707 &_swigt__p_wxNotifyEvent,
37708 &_swigt__p_wxObject,
37709 &_swigt__p_wxOutputStream,
37710 &_swigt__p_wxPCXHandler,
37711 &_swigt__p_wxPNGHandler,
37712 &_swigt__p_wxPNMHandler,
37713 &_swigt__p_wxPaintEvent,
37714 &_swigt__p_wxPaletteChangedEvent,
37715 &_swigt__p_wxPaperSize,
37716 &_swigt__p_wxPoint,
37717 &_swigt__p_wxProcessEvent,
37718 &_swigt__p_wxPyApp,
37719 &_swigt__p_wxPyArtProvider,
37720 &_swigt__p_wxPyBitmapDataObject,
37721 &_swigt__p_wxPyCommandEvent,
37722 &_swigt__p_wxPyDataObjectSimple,
37723 &_swigt__p_wxPyDropSource,
37724 &_swigt__p_wxPyDropTarget,
37725 &_swigt__p_wxPyEvent,
37726 &_swigt__p_wxPyFileDropTarget,
37727 &_swigt__p_wxPyImageHandler,
37728 &_swigt__p_wxPyLog,
37729 &_swigt__p_wxPyProcess,
37730 &_swigt__p_wxPySizer,
37731 &_swigt__p_wxPyTextDataObject,
37732 &_swigt__p_wxPyTextDropTarget,
37733 &_swigt__p_wxPyTimer,
37734 &_swigt__p_wxPyTipProvider,
37735 &_swigt__p_wxPyValidator,
37736 &_swigt__p_wxQueryNewPaletteEvent,
37737 &_swigt__p_wxRect,
37738 &_swigt__p_wxScrollEvent,
37739 &_swigt__p_wxScrollWinEvent,
37740 &_swigt__p_wxSetCursorEvent,
37741 &_swigt__p_wxShowEvent,
37742 &_swigt__p_wxSingleInstanceChecker,
37743 &_swigt__p_wxSize,
37744 &_swigt__p_wxSizeEvent,
37745 &_swigt__p_wxSizer,
37746 &_swigt__p_wxSizerItem,
37747 &_swigt__p_wxSound,
37748 &_swigt__p_wxStandardPaths,
37749 &_swigt__p_wxStaticBoxSizer,
37750 &_swigt__p_wxStdDialogButtonSizer,
37751 &_swigt__p_wxStopWatch,
37752 &_swigt__p_wxString,
37753 &_swigt__p_wxSysColourChangedEvent,
37754 &_swigt__p_wxSystemOptions,
37755 &_swigt__p_wxSystemSettings,
37756 &_swigt__p_wxTIFFHandler,
37757 &_swigt__p_wxTextCtrl,
37758 &_swigt__p_wxTextDataObject,
37759 &_swigt__p_wxTimeSpan,
37760 &_swigt__p_wxTimer,
37761 &_swigt__p_wxTimerEvent,
37762 &_swigt__p_wxTimerRunner,
37763 &_swigt__p_wxTipProvider,
37764 &_swigt__p_wxToolTip,
37765 &_swigt__p_wxURLDataObject,
37766 &_swigt__p_wxUpdateUIEvent,
37767 &_swigt__p_wxValidator,
37768 &_swigt__p_wxVideoMode,
37769 &_swigt__p_wxWindow,
37770 &_swigt__p_wxWindowCreateEvent,
37771 &_swigt__p_wxWindowDestroyEvent,
37772 &_swigt__p_wxWindowDisabler,
37773 &_swigt__p_wxXPMHandler,
37774 };
37775
37776 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37777 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37778 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37779 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37780 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37781 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37782 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37783 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37784 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37785 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}};
37786 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37787 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37788 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37789 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37790 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37791 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37792 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37793 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37794 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}};
37795 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37796 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37797 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37798 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37799 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37800 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}};
37801 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37802 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}};
37803 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37804 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37805 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37806 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37807 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37808 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37809 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37810 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37811 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37812 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37813 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37814 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37815 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37816 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37817 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37818 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37819 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37820 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37821 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37822 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37823 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37824 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37825 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37826 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37827 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
37828 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37829 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37830 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37831 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37832 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37833 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37834 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37835 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37836 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37837 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37838 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37839 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37840 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37841 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37842 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37843 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37844 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37845 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_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}};
37846 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37847 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37848 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37849 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37850 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37851 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37852 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}};
37853 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37854 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37855 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37856 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37857 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37858 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37859 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37860 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37861 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37862 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37863 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37864 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}};
37865 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37866 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37867 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37868 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37869 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37870 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37871 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37872 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37873 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37874 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
37875 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37876 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37877 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37878 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37879 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37880 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37881 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37882 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37883 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37884 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37885 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37886 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37887 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37888 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37889 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37890 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37891 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37892 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37893 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37894 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37895 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37896 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37897 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
37898 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
37899 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
37900 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
37901 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
37902 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
37903 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
37904 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
37905 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
37906 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
37907 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
37908 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
37909 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_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_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_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_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_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_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_wxProcessEvent, _p_wxProcessEventTo_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}};
37910 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
37911 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
37912 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
37913 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
37914 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
37915 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
37916 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
37917 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
37918 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}};
37919 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37920 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
37921 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
37922 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
37923 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37924 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
37925 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
37926 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
37927 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
37928 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
37929 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
37930 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
37931 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
37932 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
37933 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
37934 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
37935 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37936 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}};
37937 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
37938 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
37939 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
37940 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
37941 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}};
37942 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
37943 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
37944 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
37945 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}};
37946 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
37947
37948 static swig_cast_info *swig_cast_initial[] = {
37949 _swigc__p_char,
37950 _swigc__p_form_ops_t,
37951 _swigc__p_int,
37952 _swigc__p_unsigned_char,
37953 _swigc__p_unsigned_int,
37954 _swigc__p_unsigned_long,
37955 _swigc__p_void,
37956 _swigc__p_wxANIHandler,
37957 _swigc__p_wxAcceleratorTable,
37958 _swigc__p_wxActivateEvent,
37959 _swigc__p_wxArrayString,
37960 _swigc__p_wxBMPHandler,
37961 _swigc__p_wxBitmap,
37962 _swigc__p_wxBitmapDataObject,
37963 _swigc__p_wxBoxSizer,
37964 _swigc__p_wxBusyCursor,
37965 _swigc__p_wxBusyInfo,
37966 _swigc__p_wxCURHandler,
37967 _swigc__p_wxCaret,
37968 _swigc__p_wxChar,
37969 _swigc__p_wxChildFocusEvent,
37970 _swigc__p_wxClipboard,
37971 _swigc__p_wxClipboardLocker,
37972 _swigc__p_wxClipboardTextEvent,
37973 _swigc__p_wxCloseEvent,
37974 _swigc__p_wxColour,
37975 _swigc__p_wxCommandEvent,
37976 _swigc__p_wxConfig,
37977 _swigc__p_wxConfigBase,
37978 _swigc__p_wxConfigPathChanger,
37979 _swigc__p_wxContextMenuEvent,
37980 _swigc__p_wxControl,
37981 _swigc__p_wxControlWithItems,
37982 _swigc__p_wxCursor,
37983 _swigc__p_wxCustomDataObject,
37984 _swigc__p_wxDC,
37985 _swigc__p_wxDataFormat,
37986 _swigc__p_wxDataObject,
37987 _swigc__p_wxDataObjectComposite,
37988 _swigc__p_wxDataObjectSimple,
37989 _swigc__p_wxDateEvent,
37990 _swigc__p_wxDateSpan,
37991 _swigc__p_wxDateTime,
37992 _swigc__p_wxDateTime__TimeZone,
37993 _swigc__p_wxDisplay,
37994 _swigc__p_wxDisplayChangedEvent,
37995 _swigc__p_wxDropFilesEvent,
37996 _swigc__p_wxDuplexMode,
37997 _swigc__p_wxEraseEvent,
37998 _swigc__p_wxEvent,
37999 _swigc__p_wxEvtHandler,
38000 _swigc__p_wxFSFile,
38001 _swigc__p_wxFileConfig,
38002 _swigc__p_wxFileDataObject,
38003 _swigc__p_wxFileHistory,
38004 _swigc__p_wxFileSystem,
38005 _swigc__p_wxFileType,
38006 _swigc__p_wxFileTypeInfo,
38007 _swigc__p_wxFlexGridSizer,
38008 _swigc__p_wxFocusEvent,
38009 _swigc__p_wxFont,
38010 _swigc__p_wxFrame,
38011 _swigc__p_wxGBSizerItem,
38012 _swigc__p_wxGIFHandler,
38013 _swigc__p_wxGridBagSizer,
38014 _swigc__p_wxGridSizer,
38015 _swigc__p_wxICOHandler,
38016 _swigc__p_wxIcon,
38017 _swigc__p_wxIconizeEvent,
38018 _swigc__p_wxIdleEvent,
38019 _swigc__p_wxImage,
38020 _swigc__p_wxImageHandler,
38021 _swigc__p_wxIndividualLayoutConstraint,
38022 _swigc__p_wxInitDialogEvent,
38023 _swigc__p_wxJPEGHandler,
38024 _swigc__p_wxJoystick,
38025 _swigc__p_wxJoystickEvent,
38026 _swigc__p_wxKeyEvent,
38027 _swigc__p_wxKillError,
38028 _swigc__p_wxLayoutConstraints,
38029 _swigc__p_wxLog,
38030 _swigc__p_wxLogBuffer,
38031 _swigc__p_wxLogChain,
38032 _swigc__p_wxLogGui,
38033 _swigc__p_wxLogNull,
38034 _swigc__p_wxLogStderr,
38035 _swigc__p_wxLogTextCtrl,
38036 _swigc__p_wxLogWindow,
38037 _swigc__p_wxMaximizeEvent,
38038 _swigc__p_wxMemorySize,
38039 _swigc__p_wxMenu,
38040 _swigc__p_wxMenuBar,
38041 _swigc__p_wxMenuEvent,
38042 _swigc__p_wxMenuItem,
38043 _swigc__p_wxMetafile,
38044 _swigc__p_wxMetafileDataObject,
38045 _swigc__p_wxMimeTypesManager,
38046 _swigc__p_wxMouseCaptureChangedEvent,
38047 _swigc__p_wxMouseEvent,
38048 _swigc__p_wxMouseState,
38049 _swigc__p_wxMoveEvent,
38050 _swigc__p_wxMutexGuiLocker,
38051 _swigc__p_wxNavigationKeyEvent,
38052 _swigc__p_wxNcPaintEvent,
38053 _swigc__p_wxNotifyEvent,
38054 _swigc__p_wxObject,
38055 _swigc__p_wxOutputStream,
38056 _swigc__p_wxPCXHandler,
38057 _swigc__p_wxPNGHandler,
38058 _swigc__p_wxPNMHandler,
38059 _swigc__p_wxPaintEvent,
38060 _swigc__p_wxPaletteChangedEvent,
38061 _swigc__p_wxPaperSize,
38062 _swigc__p_wxPoint,
38063 _swigc__p_wxProcessEvent,
38064 _swigc__p_wxPyApp,
38065 _swigc__p_wxPyArtProvider,
38066 _swigc__p_wxPyBitmapDataObject,
38067 _swigc__p_wxPyCommandEvent,
38068 _swigc__p_wxPyDataObjectSimple,
38069 _swigc__p_wxPyDropSource,
38070 _swigc__p_wxPyDropTarget,
38071 _swigc__p_wxPyEvent,
38072 _swigc__p_wxPyFileDropTarget,
38073 _swigc__p_wxPyImageHandler,
38074 _swigc__p_wxPyLog,
38075 _swigc__p_wxPyProcess,
38076 _swigc__p_wxPySizer,
38077 _swigc__p_wxPyTextDataObject,
38078 _swigc__p_wxPyTextDropTarget,
38079 _swigc__p_wxPyTimer,
38080 _swigc__p_wxPyTipProvider,
38081 _swigc__p_wxPyValidator,
38082 _swigc__p_wxQueryNewPaletteEvent,
38083 _swigc__p_wxRect,
38084 _swigc__p_wxScrollEvent,
38085 _swigc__p_wxScrollWinEvent,
38086 _swigc__p_wxSetCursorEvent,
38087 _swigc__p_wxShowEvent,
38088 _swigc__p_wxSingleInstanceChecker,
38089 _swigc__p_wxSize,
38090 _swigc__p_wxSizeEvent,
38091 _swigc__p_wxSizer,
38092 _swigc__p_wxSizerItem,
38093 _swigc__p_wxSound,
38094 _swigc__p_wxStandardPaths,
38095 _swigc__p_wxStaticBoxSizer,
38096 _swigc__p_wxStdDialogButtonSizer,
38097 _swigc__p_wxStopWatch,
38098 _swigc__p_wxString,
38099 _swigc__p_wxSysColourChangedEvent,
38100 _swigc__p_wxSystemOptions,
38101 _swigc__p_wxSystemSettings,
38102 _swigc__p_wxTIFFHandler,
38103 _swigc__p_wxTextCtrl,
38104 _swigc__p_wxTextDataObject,
38105 _swigc__p_wxTimeSpan,
38106 _swigc__p_wxTimer,
38107 _swigc__p_wxTimerEvent,
38108 _swigc__p_wxTimerRunner,
38109 _swigc__p_wxTipProvider,
38110 _swigc__p_wxToolTip,
38111 _swigc__p_wxURLDataObject,
38112 _swigc__p_wxUpdateUIEvent,
38113 _swigc__p_wxValidator,
38114 _swigc__p_wxVideoMode,
38115 _swigc__p_wxWindow,
38116 _swigc__p_wxWindowCreateEvent,
38117 _swigc__p_wxWindowDestroyEvent,
38118 _swigc__p_wxWindowDisabler,
38119 _swigc__p_wxXPMHandler,
38120 };
38121
38122
38123 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38124
38125 static swig_const_info swig_const_table[] = {
38126 {0, 0, 0, 0.0, 0, 0}};
38127
38128 #ifdef __cplusplus
38129 }
38130 #endif
38131 /* -----------------------------------------------------------------------------
38132 * Type initialization:
38133 * This problem is tough by the requirement that no dynamic
38134 * memory is used. Also, since swig_type_info structures store pointers to
38135 * swig_cast_info structures and swig_cast_info structures store pointers back
38136 * to swig_type_info structures, we need some lookup code at initialization.
38137 * The idea is that swig generates all the structures that are needed.
38138 * The runtime then collects these partially filled structures.
38139 * The SWIG_InitializeModule function takes these initial arrays out of
38140 * swig_module, and does all the lookup, filling in the swig_module.types
38141 * array with the correct data and linking the correct swig_cast_info
38142 * structures together.
38143 *
38144 * The generated swig_type_info structures are assigned staticly to an initial
38145 * array. We just loop though that array, and handle each type individually.
38146 * First we lookup if this type has been already loaded, and if so, use the
38147 * loaded structure instead of the generated one. Then we have to fill in the
38148 * cast linked list. The cast data is initially stored in something like a
38149 * two-dimensional array. Each row corresponds to a type (there are the same
38150 * number of rows as there are in the swig_type_initial array). Each entry in
38151 * a column is one of the swig_cast_info structures for that type.
38152 * The cast_initial array is actually an array of arrays, because each row has
38153 * a variable number of columns. So to actually build the cast linked list,
38154 * we find the array of casts associated with the type, and loop through it
38155 * adding the casts to the list. The one last trick we need to do is making
38156 * sure the type pointer in the swig_cast_info struct is correct.
38157 *
38158 * First off, we lookup the cast->type name to see if it is already loaded.
38159 * There are three cases to handle:
38160 * 1) If the cast->type has already been loaded AND the type we are adding
38161 * casting info to has not been loaded (it is in this module), THEN we
38162 * replace the cast->type pointer with the type pointer that has already
38163 * been loaded.
38164 * 2) If BOTH types (the one we are adding casting info to, and the
38165 * cast->type) are loaded, THEN the cast info has already been loaded by
38166 * the previous module so we just ignore it.
38167 * 3) Finally, if cast->type has not already been loaded, then we add that
38168 * swig_cast_info to the linked list (because the cast->type) pointer will
38169 * be correct.
38170 * ----------------------------------------------------------------------------- */
38171
38172 #ifdef __cplusplus
38173 extern "C" {
38174 #if 0
38175 } /* c-mode */
38176 #endif
38177 #endif
38178
38179 #if 0
38180 #define SWIGRUNTIME_DEBUG
38181 #endif
38182
38183 SWIGRUNTIME void
38184 SWIG_InitializeModule(void *clientdata) {
38185 size_t i;
38186 swig_module_info *module_head;
38187 static int init_run = 0;
38188
38189 clientdata = clientdata;
38190
38191 if (init_run) return;
38192 init_run = 1;
38193
38194 /* Initialize the swig_module */
38195 swig_module.type_initial = swig_type_initial;
38196 swig_module.cast_initial = swig_cast_initial;
38197
38198 /* Try and load any already created modules */
38199 module_head = SWIG_GetModule(clientdata);
38200 if (module_head) {
38201 swig_module.next = module_head->next;
38202 module_head->next = &swig_module;
38203 } else {
38204 /* This is the first module loaded */
38205 swig_module.next = &swig_module;
38206 SWIG_SetModule(clientdata, &swig_module);
38207 }
38208
38209 /* Now work on filling in swig_module.types */
38210 #ifdef SWIGRUNTIME_DEBUG
38211 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38212 #endif
38213 for (i = 0; i < swig_module.size; ++i) {
38214 swig_type_info *type = 0;
38215 swig_type_info *ret;
38216 swig_cast_info *cast;
38217
38218 #ifdef SWIGRUNTIME_DEBUG
38219 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38220 #endif
38221
38222 /* if there is another module already loaded */
38223 if (swig_module.next != &swig_module) {
38224 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38225 }
38226 if (type) {
38227 /* Overwrite clientdata field */
38228 #ifdef SWIGRUNTIME_DEBUG
38229 printf("SWIG_InitializeModule: found type %s\n", type->name);
38230 #endif
38231 if (swig_module.type_initial[i]->clientdata) {
38232 type->clientdata = swig_module.type_initial[i]->clientdata;
38233 #ifdef SWIGRUNTIME_DEBUG
38234 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38235 #endif
38236 }
38237 } else {
38238 type = swig_module.type_initial[i];
38239 }
38240
38241 /* Insert casting types */
38242 cast = swig_module.cast_initial[i];
38243 while (cast->type) {
38244 /* Don't need to add information already in the list */
38245 ret = 0;
38246 #ifdef SWIGRUNTIME_DEBUG
38247 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38248 #endif
38249 if (swig_module.next != &swig_module) {
38250 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38251 #ifdef SWIGRUNTIME_DEBUG
38252 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38253 #endif
38254 }
38255 if (ret) {
38256 if (type == swig_module.type_initial[i]) {
38257 #ifdef SWIGRUNTIME_DEBUG
38258 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38259 #endif
38260 cast->type = ret;
38261 ret = 0;
38262 } else {
38263 /* Check for casting already in the list */
38264 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38265 #ifdef SWIGRUNTIME_DEBUG
38266 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38267 #endif
38268 if (!ocast) ret = 0;
38269 }
38270 }
38271
38272 if (!ret) {
38273 #ifdef SWIGRUNTIME_DEBUG
38274 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38275 #endif
38276 if (type->cast) {
38277 type->cast->prev = cast;
38278 cast->next = type->cast;
38279 }
38280 type->cast = cast;
38281 }
38282 cast++;
38283 }
38284 /* Set entry in modules->types array equal to the type */
38285 swig_module.types[i] = type;
38286 }
38287 swig_module.types[i] = 0;
38288
38289 #ifdef SWIGRUNTIME_DEBUG
38290 printf("**** SWIG_InitializeModule: Cast List ******\n");
38291 for (i = 0; i < swig_module.size; ++i) {
38292 int j = 0;
38293 swig_cast_info *cast = swig_module.cast_initial[i];
38294 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38295 while (cast->type) {
38296 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38297 cast++;
38298 ++j;
38299 }
38300 printf("---- Total casts: %d\n",j);
38301 }
38302 printf("**** SWIG_InitializeModule: Cast List ******\n");
38303 #endif
38304 }
38305
38306 /* This function will propagate the clientdata field of type to
38307 * any new swig_type_info structures that have been added into the list
38308 * of equivalent types. It is like calling
38309 * SWIG_TypeClientData(type, clientdata) a second time.
38310 */
38311 SWIGRUNTIME void
38312 SWIG_PropagateClientData(void) {
38313 size_t i;
38314 swig_cast_info *equiv;
38315 static int init_run = 0;
38316
38317 if (init_run) return;
38318 init_run = 1;
38319
38320 for (i = 0; i < swig_module.size; i++) {
38321 if (swig_module.types[i]->clientdata) {
38322 equiv = swig_module.types[i]->cast;
38323 while (equiv) {
38324 if (!equiv->converter) {
38325 if (equiv->type && !equiv->type->clientdata)
38326 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38327 }
38328 equiv = equiv->next;
38329 }
38330 }
38331 }
38332 }
38333
38334 #ifdef __cplusplus
38335 #if 0
38336 {
38337 /* c-mode */
38338 #endif
38339 }
38340 #endif
38341
38342
38343
38344 #ifdef __cplusplus
38345 extern "C" {
38346 #endif
38347
38348 /* Python-specific SWIG API */
38349 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38350 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38351 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38352
38353 /* -----------------------------------------------------------------------------
38354 * global variable support code.
38355 * ----------------------------------------------------------------------------- */
38356
38357 typedef struct swig_globalvar {
38358 char *name; /* Name of global variable */
38359 PyObject *(*get_attr)(void); /* Return the current value */
38360 int (*set_attr)(PyObject *); /* Set the value */
38361 struct swig_globalvar *next;
38362 } swig_globalvar;
38363
38364 typedef struct swig_varlinkobject {
38365 PyObject_HEAD
38366 swig_globalvar *vars;
38367 } swig_varlinkobject;
38368
38369 SWIGINTERN PyObject *
38370 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38371 return PyString_FromString("<Swig global variables>");
38372 }
38373
38374 SWIGINTERN PyObject *
38375 swig_varlink_str(swig_varlinkobject *v) {
38376 PyObject *str = PyString_FromString("(");
38377 swig_globalvar *var;
38378 for (var = v->vars; var; var=var->next) {
38379 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38380 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38381 }
38382 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38383 return str;
38384 }
38385
38386 SWIGINTERN int
38387 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38388 PyObject *str = swig_varlink_str(v);
38389 fprintf(fp,"Swig global variables ");
38390 fprintf(fp,"%s\n", PyString_AsString(str));
38391 Py_DECREF(str);
38392 return 0;
38393 }
38394
38395 SWIGINTERN void
38396 swig_varlink_dealloc(swig_varlinkobject *v) {
38397 swig_globalvar *var = v->vars;
38398 while (var) {
38399 swig_globalvar *n = var->next;
38400 free(var->name);
38401 free(var);
38402 var = n;
38403 }
38404 }
38405
38406 SWIGINTERN PyObject *
38407 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38408 PyObject *res = NULL;
38409 swig_globalvar *var = v->vars;
38410 while (var) {
38411 if (strcmp(var->name,n) == 0) {
38412 res = (*var->get_attr)();
38413 break;
38414 }
38415 var = var->next;
38416 }
38417 if (res == NULL && !PyErr_Occurred()) {
38418 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38419 }
38420 return res;
38421 }
38422
38423 SWIGINTERN int
38424 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38425 int res = 1;
38426 swig_globalvar *var = v->vars;
38427 while (var) {
38428 if (strcmp(var->name,n) == 0) {
38429 res = (*var->set_attr)(p);
38430 break;
38431 }
38432 var = var->next;
38433 }
38434 if (res == 1 && !PyErr_Occurred()) {
38435 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38436 }
38437 return res;
38438 }
38439
38440 SWIGINTERN PyTypeObject*
38441 swig_varlink_type(void) {
38442 static char varlink__doc__[] = "Swig var link object";
38443 static PyTypeObject varlink_type;
38444 static int type_init = 0;
38445 if (!type_init) {
38446 const PyTypeObject tmp
38447 = {
38448 PyObject_HEAD_INIT(NULL)
38449 0, /* Number of items in variable part (ob_size) */
38450 (char *)"swigvarlink", /* Type name (tp_name) */
38451 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38452 0, /* Itemsize (tp_itemsize) */
38453 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38454 (printfunc) swig_varlink_print, /* Print (tp_print) */
38455 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38456 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38457 0, /* tp_compare */
38458 (reprfunc) swig_varlink_repr, /* tp_repr */
38459 0, /* tp_as_number */
38460 0, /* tp_as_sequence */
38461 0, /* tp_as_mapping */
38462 0, /* tp_hash */
38463 0, /* tp_call */
38464 (reprfunc)swig_varlink_str, /* tp_str */
38465 0, /* tp_getattro */
38466 0, /* tp_setattro */
38467 0, /* tp_as_buffer */
38468 0, /* tp_flags */
38469 varlink__doc__, /* tp_doc */
38470 0, /* tp_traverse */
38471 0, /* tp_clear */
38472 0, /* tp_richcompare */
38473 0, /* tp_weaklistoffset */
38474 #if PY_VERSION_HEX >= 0x02020000
38475 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38476 #endif
38477 #if PY_VERSION_HEX >= 0x02030000
38478 0, /* tp_del */
38479 #endif
38480 #ifdef COUNT_ALLOCS
38481 0,0,0,0 /* tp_alloc -> tp_next */
38482 #endif
38483 };
38484 varlink_type = tmp;
38485 varlink_type.ob_type = &PyType_Type;
38486 type_init = 1;
38487 }
38488 return &varlink_type;
38489 }
38490
38491 /* Create a variable linking object for use later */
38492 SWIGINTERN PyObject *
38493 SWIG_Python_newvarlink(void) {
38494 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38495 if (result) {
38496 result->vars = 0;
38497 }
38498 return ((PyObject*) result);
38499 }
38500
38501 SWIGINTERN void
38502 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38503 swig_varlinkobject *v = (swig_varlinkobject *) p;
38504 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38505 if (gv) {
38506 size_t size = strlen(name)+1;
38507 gv->name = (char *)malloc(size);
38508 if (gv->name) {
38509 strncpy(gv->name,name,size);
38510 gv->get_attr = get_attr;
38511 gv->set_attr = set_attr;
38512 gv->next = v->vars;
38513 }
38514 }
38515 v->vars = gv;
38516 }
38517
38518 SWIGINTERN PyObject *
38519 SWIG_globals() {
38520 static PyObject *_SWIG_globals = 0;
38521 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38522 return _SWIG_globals;
38523 }
38524
38525 /* -----------------------------------------------------------------------------
38526 * constants/methods manipulation
38527 * ----------------------------------------------------------------------------- */
38528
38529 /* Install Constants */
38530 SWIGINTERN void
38531 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38532 PyObject *obj = 0;
38533 size_t i;
38534 for (i = 0; constants[i].type; ++i) {
38535 switch(constants[i].type) {
38536 case SWIG_PY_POINTER:
38537 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38538 break;
38539 case SWIG_PY_BINARY:
38540 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38541 break;
38542 default:
38543 obj = 0;
38544 break;
38545 }
38546 if (obj) {
38547 PyDict_SetItemString(d, constants[i].name, obj);
38548 Py_DECREF(obj);
38549 }
38550 }
38551 }
38552
38553 /* -----------------------------------------------------------------------------*/
38554 /* Fix SwigMethods to carry the callback ptrs when needed */
38555 /* -----------------------------------------------------------------------------*/
38556
38557 SWIGINTERN void
38558 SWIG_Python_FixMethods(PyMethodDef *methods,
38559 swig_const_info *const_table,
38560 swig_type_info **types,
38561 swig_type_info **types_initial) {
38562 size_t i;
38563 for (i = 0; methods[i].ml_name; ++i) {
38564 char *c = methods[i].ml_doc;
38565 if (c && (c = strstr(c, "swig_ptr: "))) {
38566 int j;
38567 swig_const_info *ci = 0;
38568 char *name = c + 10;
38569 for (j = 0; const_table[j].type; ++j) {
38570 if (strncmp(const_table[j].name, name,
38571 strlen(const_table[j].name)) == 0) {
38572 ci = &(const_table[j]);
38573 break;
38574 }
38575 }
38576 if (ci) {
38577 size_t shift = (ci->ptype) - types;
38578 swig_type_info *ty = types_initial[shift];
38579 size_t ldoc = (c - methods[i].ml_doc);
38580 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38581 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38582 if (ndoc) {
38583 char *buff = ndoc;
38584 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38585 if (ptr) {
38586 strncpy(buff, methods[i].ml_doc, ldoc);
38587 buff += ldoc;
38588 strncpy(buff, "swig_ptr: ", 10);
38589 buff += 10;
38590 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38591 methods[i].ml_doc = ndoc;
38592 }
38593 }
38594 }
38595 }
38596 }
38597 }
38598
38599 #ifdef __cplusplus
38600 }
38601 #endif
38602
38603 /* -----------------------------------------------------------------------------*
38604 * Partial Init method
38605 * -----------------------------------------------------------------------------*/
38606
38607 #ifdef __cplusplus
38608 extern "C"
38609 #endif
38610 SWIGEXPORT void SWIG_init(void) {
38611 PyObject *m, *d;
38612
38613 /* Fix SwigMethods to carry the callback ptrs when needed */
38614 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38615
38616 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38617 d = PyModule_GetDict(m);
38618
38619 SWIG_InitializeModule(0);
38620 SWIG_InstallConstants(d,swig_const_table);
38621
38622
38623 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38624 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38625 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38626 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38627 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38628 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38629 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38630 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38631 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38632 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38633 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38634 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38635 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38636 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38637 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38638 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38639 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38640 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38641 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38642 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38643 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38644 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38645 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38646 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38647 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38648 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38649 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38650 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38651 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38652 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38653 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38654 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38655 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38656 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38657 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38658 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38659 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38660 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38661 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38662 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38663 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38664 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38665 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38666 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38667 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38668 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38669 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38670 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38671 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38672 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38673 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38674 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38675 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38676 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38677 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38678 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38679 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38680 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38681 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38682 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38683 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38684 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38685 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38686 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38687 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38688 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38689 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38690 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38691 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38692 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38693 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38694 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38695 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38696 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38697 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38698 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38699 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38700 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38701 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38702 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38703 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38704 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38705 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38706 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38707 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38708 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38709 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38710 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38711 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38712 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38713 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38714 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38715 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38716 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38717 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38718 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38719 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38720 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38721 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38722 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38723 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38724 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38725
38726 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38727
38728 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38729 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38730 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38731 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38732 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38733 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38734 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38735 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38736 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38737 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38738 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38739 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38740 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38741 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38742 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38743 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38744 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38745 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38746 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38747 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38748 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38749 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38750 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38751 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38752 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38753 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38754 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38755 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38756 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38757 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38758 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38759 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38760 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38761 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38762 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38763 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38764 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38765 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38766 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38767 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38768 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38769 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38770 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38771 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38772 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38773 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38774 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38775 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38776 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38777 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38778 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38779 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38780 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38781
38782 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38783
38784 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38785 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38786 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38787 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38788 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38789 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38790 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38791 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38792 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38793 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38794 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38795 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38796 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38797 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38798 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38799 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38800 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38801 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38802 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38803 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38804 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38805 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38806 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38807 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38808 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38809 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38810 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38811 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38812 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38813 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38814 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38815 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38816 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38817 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38818 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38819 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38820 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38821 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38822 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38823 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38824 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38825 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38826 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38827 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38828 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38829 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38830 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38831 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38832 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38833 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38834 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38835 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38836 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38837 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38838 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38839 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38840 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38841 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38842 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38843 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38844 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38845 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38846 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38847 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38848 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38849 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38850 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38851 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38852 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38853 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38854 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38855 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38856 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38857 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38858 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38859 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38860
38861 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38862
38863 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38864 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38865 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38866 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38867 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38868 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38869 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38870 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38871 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38872 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38873 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38874 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38875 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38876 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38877 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38878 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38879 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38880 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38881 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38882 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38883 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38884 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38885 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38886 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38887 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38888 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38889 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38890 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38891 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38892 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38893 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38894 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38895 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38896 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
38897 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
38898 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
38899 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
38900 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
38901 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
38902 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
38903 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
38904 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
38905 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
38906 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
38907 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
38908 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
38909 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
38910 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
38911 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
38912 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
38913 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
38914 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
38915 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
38916 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
38917 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
38918 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
38919 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
38920 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
38921 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
38922 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
38923 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
38924 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
38925 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
38926 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
38927 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
38928 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
38929 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
38930 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
38931 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
38932 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
38933 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
38934 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
38935 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
38936 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
38937 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
38938 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
38939 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
38940 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
38941 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
38942 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
38943 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
38944 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
38945 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
38946 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
38947 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
38948 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
38949 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
38950 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
38951 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
38952 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
38953 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
38954 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
38955 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
38956 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
38957 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
38958 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
38959 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
38960 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
38961 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
38962 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
38963 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
38964 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
38965 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
38966 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
38967 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
38968 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
38969 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
38970 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
38971 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
38972 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
38973 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
38974 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
38975 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
38976 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
38977 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
38978 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
38979 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
38980 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
38981 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
38982 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
38983 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
38984 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
38985 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
38986 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
38987 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
38988 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
38989 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
38990 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
38991 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
38992 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
38993 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
38994 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
38995 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
38996 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
38997 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
38998 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
38999 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39000 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39001 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39002 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39003 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39004 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39005 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39006 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39007 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39008 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39009 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39010 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39011 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39012 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39013 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39014 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39015 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39016 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39017 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39018 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39019 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39020 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39021 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39022 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39023 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39024 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39025 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39026 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39027 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39028 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39029 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39030 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39031 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39032 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39033 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39034 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39035 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39036 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39037 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39038 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39039 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39040 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39041 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39042 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39043 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39044 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39045 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39046 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39047 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39048 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39049 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39050 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39051 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39052 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39053 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39054 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39055 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39056 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39057 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39058 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39059 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39060 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39061 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39062 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39063
39064 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39065 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39066 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39067 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39068
39069 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39070 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39071 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39072 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39073 }
39074
wxWidgets (Impactor)